hx-cli 0.2.17__tar.gz → 0.2.18__tar.gz

{hx_cli-0.2.17 → hx_cli-0.2.18}/CHANGELOG.md

@@ -28,6 +28,28 @@ the project follows [semantic versioning](https://semver.org/).
 
 ---
 
+## [0.2.18] - 2026-10-18
+
+### Security
+
+- Edit and Write no longer leave a private file's new content readable by other users while
+  they write it. The temporary file now gets the file's own mode before any content goes in.
+
+### Fixed
+
+- An edit through a symlink says which file it changes. The approval reads "config.yml is a
+  link to ~/shared/config.yml", and so does the answered approval and the result the model
+  gets. A link into a missing directory is refused in words, not with a raw error.
+- The transcript names a symlink by its own name, not by the name of its target.
+- A failed tool's error wraps in the transcript instead of being cut at the window's edge, so
+  a reason that comes after a long path stays readable.
+- An edit to a CRLF file that differs only in line endings is refused as identical. It used to
+  be reported as applied, with nothing changed.
+- Counts of one read in the singular when a limit leaves something out: "1 more line",
+  "1 more match", "1 more result". So do the other counts that still had "1 lines" forms.
+
+---
+
 ## [0.2.17] - 2026-10-18
 
 ### Security
@@ -958,7 +980,8 @@ First release, published to PyPI as [`hx-cli`](https://pypi.org/project/hx-cli/)
 - `/configure` and `hx auth` for the OpenRouter key, `hx upgrade` for
   self-update, and `install.sh` bootstrapping uv with a pinned Python.
 
-[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.17...HEAD
+[Unreleased]: https://github.com/aletisunil/hx/compare/v0.2.18...HEAD
+[0.2.18]: https://github.com/aletisunil/hx/compare/v0.2.17...v0.2.18
 [0.2.17]: https://github.com/aletisunil/hx/compare/v0.2.16...v0.2.17
 [0.2.16]: https://github.com/aletisunil/hx/compare/v0.2.15...v0.2.16
 [0.2.15]: https://github.com/aletisunil/hx/compare/v0.2.14...v0.2.15

{hx_cli-0.2.17 → hx_cli-0.2.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hx-cli
-Version: 0.2.17
+Version: 0.2.18
 Summary: HX - an agent harness for the terminal
 Project-URL: Homepage, https://hx.sunilaleti.dev
 Project-URL: Documentation, https://hx.sunilaleti.dev

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/__init__.py

@@ -1,5 +1,5 @@
 """HX - an agent harness for the terminal."""
 
-__version__ = "0.2.17"
+__version__ = "0.2.18"
 
 __all__ = ["__version__"]

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/core/loop.py

@@ -889,6 +889,7 @@ class AgentLoop:
             description=f"{call.name}({_brief(call.input)})",
             detail=detail,
             detail_kind=detail_kind,
+            link_target=_link_target(call, self.settings.cwd),
             origin=self.origin,
             tool_use_id=call.id,
         )
@@ -1085,6 +1086,20 @@ def _permission_detail(call: ToolUseBlock, cwd: Path) -> tuple[str, str]:
     return _detailed(call.input), "text"
 
 
+def _link_target(call: ToolUseBlock, cwd: Path) -> str | None:
+    """Where an Edit or Write lands when the path it names is a symlink."""
+    if call.name not in {"Edit", "Write"} or not (raw_path := call.input.get("file_path")):
+        return None
+    from hx.tools.read import resolve_path
+    from hx.tools.write import link_target
+
+    try:
+        target = link_target(resolve_path(str(raw_path), cwd))
+    except (OSError, RuntimeError):  # a link loop, or a directory we cannot see into
+        return None
+    return str(target) if target is not None else None
+
+
 def _detailed(params: dict[str, Any], limit: int = 400) -> str:
     """What the approval prompt shows for a tool with no preview of its own.
 

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/mcp/client.py

@@ -20,6 +20,7 @@ import httpx
 
 from hx import __version__
 from hx.net import async_client
+from hx.text import count
 
 if TYPE_CHECKING:
     from hx.mcp.oauth import OAuthSession
@@ -531,11 +532,7 @@ class MCPClient:
         if result.get("isError"):
             raise MCPToolError(text or f"{name} failed")
         if not text:
-            text = (
-                f"({len(images)} image{'s' if len(images) != 1 else ''})"
-                if images
-                else "(no content)"
-            )
+            text = f"({count(len(images), 'image')})" if images else "(no content)"
         return MCPToolOutput(text=text, images=images)
 
     async def _request(

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/permissions/engine.py

@@ -76,6 +76,12 @@ class PermissionRequest:
     that painter strips exactly those lines, so the user was asked to approve a
     blank space.
     """
+    link_target: str | None = None
+    """The file an edit really changes, when the path it names is a symlink.
+
+    The link can point anywhere, out of the project included, and the diff
+    alone does not say where it lands.
+    """
     origin: str | None = None
     """Which subagent asked, when it was not the main conversation."""
     tool_use_id: str | None = None

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/tools/edit.py

@@ -14,14 +14,16 @@ from __future__ import annotations
 
 import asyncio
 import difflib
+import re
+from collections.abc import Iterator
 from dataclasses import dataclass
-from typing import TYPE_CHECKING, Any
+from typing import TYPE_CHECKING, Any, Literal
 
 from hx.text import count
 from hx.tools import anchors
 from hx.tools.base import Tool, ToolContext, ToolError, ToolResult
 from hx.tools.read import FileTracker, hashline_enabled, read_exact, resolve_path
-from hx.tools.write import write_atomic
+from hx.tools.write import through_link, write_atomic
 
 if TYPE_CHECKING:
     from hx.core.checkpoints import CheckpointStore
@@ -162,7 +164,7 @@ class EditTool(Tool):
         diff = unified_diff(before, after, str(path))
         added, removed = count_changes(diff)
         return ToolResult(
-            content=f"Applied {count(applied, 'edit')} to {path}.\n\n{diff}",
+            content=f"Applied {count(applied, 'edit')} to {path}{through_link(path)}.\n\n{diff}",
             summary=f"{path.name} +{added} -{removed}",
             metadata={"path": str(path), "diff": diff},
         )
@@ -192,6 +194,14 @@ def apply_edits(content: str, edits: list[EditOp]) -> str:
             new = _crlf(new)
             if result.count(old) == 0:
                 old = _crlf(old)
+            # Compared again once both are spelled the file's way: an edit that
+            # only changed line endings came out identical here, replaced
+            # nothing, and was still reported as applied.
+            if old == new:
+                raise ToolError(
+                    f"edit {index}: old_string and new_string are identical once their "
+                    "line endings follow the file's CRLF. Edit keeps a file's line endings."
+                )
 
         occurrences = result.count(old)
         if occurrences == 0:
@@ -309,21 +319,75 @@ def parse_edits(params: dict[str, Any]) -> list[EditOp]:
     ]
 
 
-def count_changes(diff_text: str) -> tuple[int, int]:
-    """Added and removed line counts, ignoring the ``+++``/``---`` file headers.
+HUNK_HEADER = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
+
+
+@dataclass(frozen=True, slots=True)
+class DiffRow:
+    """One meaningful line of a unified diff."""
+
+    kind: Literal["file", "hunk", "line"]
+    text: str
+    """The file's name, the hunk header, or the line with its ``-``/``+``/space."""
+    header: re.Match[str] | None = None
+    """For a hunk: its parsed header, which numbers the lines that follow."""
 
-    Only lines inside a hunk are counted. Telling the headers apart by their
-    doubled sign instead skipped every changed line whose own text starts with
-    ``-`` or ``+`` - a SQL or Lua comment, ``++i``, a markdown rule.
+
+def diff_rows(diff_text: str) -> Iterator[DiffRow]:
+    """The files, hunks and changed or context lines of a unified diff.
+
+    A hunk ends where its header says, after its count of old and new lines -
+    not at the next line that looks like a header. A changed line can start
+    with ``--`` or ``++`` (a SQL comment, ``++i``), so telling headers apart by
+    their sign hid those lines; and a hunk that never ended counted the next
+    file's ``---``/``+++`` headers as one removed and one added line.
+
+    Everything between hunks other than a file's header pair - ``diff --git``,
+    ``index``, mode lines - is left out.
     """
+    lines = diff_text.splitlines()
+    old_left = new_left = 0
+    index = 0
+    while index < len(lines):
+        line = lines[index]
+        index += 1
+        if header := HUNK_HEADER.match(line):
+            old_left = int(header.group(2)) if header.group(2) is not None else 1
+            new_left = int(header.group(4)) if header.group(4) is not None else 1
+            yield DiffRow("hunk", line, header)
+        elif old_left > 0 or new_left > 0:
+            if line.startswith("\\"):
+                continue  # "" belongs to no side
+            if line.startswith("-"):
+                old_left -= 1
+            elif line.startswith("+"):
+                new_left -= 1
+            else:
+                old_left -= 1
+                new_left -= 1
+            yield DiffRow("line", line)
+        elif line.startswith("--- ") and index < len(lines) and lines[index].startswith("+++ "):
+            yield DiffRow("file", _file_name(line[4:], lines[index][4:]))
+            index += 1
+
+
+def _file_name(old: str, new: str) -> str:
+    """The path a ``---``/``+++`` pair is about: the new one, or the old one for a
+    deletion, without git's ``a/``/``b/`` prefixes or a trailing timestamp."""
+    old, new = old.split("\t", 1)[0], new.split("\t", 1)[0]
+    sides = ((old, "a/"), (new, "b/"))
+    if all(side.startswith(prefix) or side == "/dev/null" for side, prefix in sides):
+        old, new = (side if side == "/dev/null" else side[2:] for side, _ in sides)
+    return old if new == "/dev/null" else new
+
+
+def count_changes(diff_text: str) -> tuple[int, int]:
+    """Added and removed line counts, ignoring the ``+++``/``---`` file headers."""
     added = removed = 0
-    in_hunk = False
-    for line in diff_text.splitlines():
-        if line.startswith("@@"):
-            in_hunk = True
-        elif in_hunk and line.startswith("+"):
+    for row in diff_rows(diff_text):
+        if row.kind == "line" and row.text.startswith("+"):
             added += 1
-        elif in_hunk and line.startswith("-"):
+        elif row.kind == "line" and row.text.startswith("-"):
             removed += 1
     return added, removed
 

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/tools/glob.py

@@ -59,7 +59,8 @@ class GlobTool(Tool):
         shown = matches[:limit]
         body = "\n".join(str(path) for path in shown) or "(no matches)"
         if len(matches) > limit:
-            body += f"\n\n... {len(matches) - limit} more matches (raise limit to see them)"
+            more = count(len(matches) - limit, "more match", "more matches")
+            body += f"\n\n... {more} (raise limit to see them)"
         return ToolResult(content=body, summary=count(len(matches), "match", "matches"))
 
 

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/tools/grep.py

@@ -79,7 +79,7 @@ class GrepTool(Tool):
         shown = lines[:limit]
         body = "\n".join(shown) or "(no matches)"
         if len(lines) > limit:
-            body += f"\n\n... {len(lines) - limit} more results (raise limit to see them)"
+            body += f"\n\n... {count(len(lines) - limit, 'more result')} (raise limit to see them)"
         return ToolResult(content=body, summary=count(len(lines), "result"))
 
     def _ripgrep(self, pattern: str, root: Path, mode: str, params: dict[str, Any]) -> list[str]:

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/tools/read.py

@@ -69,7 +69,7 @@ class ReadTool(Tool):
             return _read_image(path)
         if is_binary(path):
             size = path.stat().st_size
-            raise ToolError(f"{path}: binary file ({size} bytes), not read as text")
+            raise ToolError(f"{path}: binary file ({count(size, 'byte')}), not read as text")
 
         offset = max(int(params.get("offset") or 1), 1)
         limit = int(params.get("limit") or DEFAULT_LINE_LIMIT)
@@ -105,7 +105,8 @@ class ReadTool(Tool):
         remaining = len(lines) - (offset - 1 + len(window))
         if remaining > 0:
             rendered += (
-                f"\n\n... {remaining} more lines. Re-read with offset={offset + len(window)}."
+                f"\n\n... {count(remaining, 'more line')}. "
+                f"Re-read with offset={offset + len(window)}."
             )
 
         if not window:

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/tools/symbols.py

@@ -23,6 +23,7 @@ from dataclasses import dataclass
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
+from hx.text import count
 from hx.tools.base import Tool, ToolContext, ToolError, ToolResult
 from hx.tools.glob import IGNORED_DIRS
 
@@ -218,7 +219,7 @@ class SymbolsTool(Tool):
         if not rows:
             return ToolResult(content=f"{path}: no definitions found", summary="0 symbols")
         body = f"{path}\n" + "\n".join(rows)
-        return ToolResult(content=body, summary=f"{len(rows)} symbols")
+        return ToolResult(content=body, summary=count(len(rows), "symbol"))
 
     def _search(
         self, mode: str, symbol: str, params: dict[str, Any], ctx: ToolContext, limit: int
@@ -251,8 +252,8 @@ class SymbolsTool(Tool):
 
         body = "\n".join(hits)
         if truncated:
-            body += f"\n\n... stopped at {limit} hits (raise limit to see more)"
-        return ToolResult(content=body, summary=f"{len(hits)} hits")
+            body += f"\n\n... stopped at {count(limit, 'hit')} (raise limit to see more)"
+        return ToolResult(content=body, summary=count(len(hits), "hit"))
 
 
 def _matches(

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/tools/write.py

@@ -88,12 +88,28 @@ class WriteTool(Tool):
         # than starting another, so "done\n" is one line, not two.
         lines = len(anchors.split(content)[0])
         return ToolResult(
-            content=f"{verb} {path} ({count(lines, 'line')})",
+            content=f"{verb} {path}{through_link(path)} ({count(lines, 'line')})",
             summary=f"{verb} {path.name}",
             metadata={"path": str(path), "created": not existed},
         )
 
 
+def link_target(path: Path) -> Path | None:
+    """The file a write to ``path`` really changes, when ``path`` is a symlink.
+
+    None for anything else. Callers name it to the user and the model, because
+    the link can point anywhere - out of the project included - and a write
+    reported against the link's own name hides where it landed.
+    """
+    return path.resolve() if path.is_symlink() else None
+
+
+def through_link(path: Path) -> str:
+    """`` through the link to <target>`` for a symlink, else nothing."""
+    target = link_target(path)
+    return f" through the link to {target}" if target is not None else ""
+
+
 def write_atomic(path: Path, content: str) -> None:
     """Write via a temp file in the same directory, then rename.
 
@@ -103,26 +119,38 @@ def write_atomic(path: Path, content: str) -> None:
     The rename replaces whatever sits at the name it lands on, so two things
     are carried over by hand. A symlink is written through - the rename lands
     on the file it points at, and the link stays a link - rather than replaced
-    by a regular file while its target goes unchanged. And the file's mode is
-    copied onto the temp file, which would otherwise turn an executable script
-    into one that no longer runs. A new file gets the mode the umask gives it.
+    by a regular file while its target goes unchanged. A link to a file that
+    does not exist yet creates it, the way a shell redirect would, provided
+    its directory exists. And the file's mode is copied onto the temp file,
+    which would otherwise turn an executable script into one that no longer
+    runs. A new file gets the mode the umask gives it.
+
+    The temp file is created with that mode, not opened wider and narrowed
+    after the write: in between, a private file's new content - an ``.env``
+    being edited - was readable by every user on the machine, and a crash in
+    that window left the readable copy on disk.
 
     Text is written as given, with no newline translation: the line endings
     in ``content`` are the ones the caller chose.
     """
-    target = path.resolve() if path.is_symlink() else path
+    target = link_target(path) or path
+    if target is not path and not target.parent.is_dir():
+        raise ToolError(f"{path} is a link to {target}, and {target.parent} does not exist")
     try:
         mode: int | None = stat.S_IMODE(target.stat().st_mode)
     except FileNotFoundError:
         mode = None
 
     tmp = target.with_name(f".{target.name}.{secrets.token_hex(4)}.hx-tmp")
-    # 0o666 through os.open, so the kernel applies the umask to a new file.
-    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o666)
+    # Through os.open, so the kernel applies the umask on top: the temp file
+    # never allows more than the file it replaces, and a new file gets 0o666
+    # less the umask.
+    fd = os.open(tmp, os.O_WRONLY | os.O_CREAT | os.O_EXCL, 0o666 if mode is None else mode)
     try:
         with os.fdopen(fd, "w", encoding="utf-8", newline="") as handle:
             handle.write(content)
         if mode is not None:
+            # Again, exactly: the umask may have taken bits the file had.
             os.chmod(tmp, mode)
         os.replace(tmp, target)
     except BaseException:

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/tui/commands.py

@@ -561,7 +561,7 @@ async def cmd_cost(ctx: CommandContext, args: str) -> None:
     # message records, and a single prompt produces many of both.
     scale = count(len(usage.turns), "API request")
     if prompts:
-        scale += f" across {prompts} prompt{'s' if prompts != 1 else ''}"
+        scale += f" across {count(prompts, 'prompt')}"
     lines = [
         f"Session cost:  {format_cost(usage.total_cost_usd)}  over {scale}",
         f"Input:         {format_tokens(usage.total_input)} uncached",
@@ -921,8 +921,8 @@ async def _run_claude_code_login(ctx: CommandContext, spec: Any) -> None:
 
     who = status.account or "your Claude account"
     plan = f", {status.plan} plan" if status.plan else ""
-    count = await _refresh_after_login(ctx, spec.id)
-    offer = f"{count} models available" if count else "Pick a model with /model"
+    models = await _refresh_after_login(ctx, spec.id)
+    offer = f"{count(models, 'model')} available" if models else "Pick a model with /model"
     ctx.app.notice(f"Claude Code signed in ({who}{plan}). {offer}.", "success")
 
 
@@ -983,8 +983,8 @@ async def _run_oauth_login(ctx: CommandContext, spec: Any) -> None:
 
     # The model list is per account, so it only means anything once there is an
     # account: ask now rather than leaving /model showing the fallback guess.
-    count = await _refresh_after_login(ctx, spec.id)
-    offer = f"{count} models available" if count else "Pick a model with /model"
+    models = await _refresh_after_login(ctx, spec.id)
+    offer = f"{count(models, 'model')} available" if models else "Pick a model with /model"
     ctx.app.notice(f"{signed_in}. {offer}.", "success")
 
 

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/tui/renderers.py

@@ -30,12 +30,12 @@ from hx.term.sanitize import plain_text
 from hx.term.syntax import highlight as highlight_source
 from hx.term.width import cell_width, truncate_to_width
 from hx.text import count
+from hx.tools.edit import HUNK_HEADER, diff_rows
 from hx.tools.edit import count_changes as _count_changes
 from hx.tui.glyphs import BASH, ELLIPSIS, TODO_ACTIVE, TODO_DONE, TODO_PENDING
 from hx.tui.limits import EXPANDED_MAX, PREVIEW_LINES, RECORD_WIDTH
 from hx.tui.paint import color_mode, fg
 
-_HUNK = re.compile(r"^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@")
 _WORD = re.compile(r"\s+|\w+|[^\w\s]")
 
 
@@ -48,9 +48,8 @@ def expand_note(hidden: int) -> str:
     """
     from hx.keys import primary_key
 
-    plural = "s" if hidden != 1 else ""
     return (
-        fg("muted", f"{ELLIPSIS} ({hidden} more line{plural}, ")
+        fg("muted", f"{ELLIPSIS} ({count(hidden, 'more line')}, ")
         + fg("dim", primary_key("app.tools.expand"))
         + fg("muted", " to expand)")
     )
@@ -146,18 +145,29 @@ def display_path(raw: Any, cwd: Path) -> str:
 
     An absolute path inside a tool header is noise - forty characters of prefix
     the user already knows, pushing the part they do not know off the edge.
+
+    The directories are resolved and the name is not, so a symlink is shown by
+    its own name. Resolved whole, ``config.yml`` linked to a file in the home
+    directory was shown as ``~/shared/config.yml``, a name the model never
+    used - and the approval naming the link and its target named one file twice.
     """
     if not raw:
         return ""
     text = str(raw)
     try:
         path = Path(text).expanduser()
+        path = path if path.is_absolute() else cwd / path
+        named = (
+            path.parent.resolve() / path.name
+            if path.name not in ("", ".", "..")
+            else path.resolve()
+        )
     except (OSError, ValueError):
         return single_row(text)
 
     for base, prefix in ((cwd, ""), (Path.home(), "~/")):
         try:
-            return single_row(prefix + str(path.resolve().relative_to(base.resolve())))
+            return single_row(prefix + str(named.relative_to(base.resolve())))
         except (OSError, ValueError):
             continue
     return single_row(text)
@@ -299,7 +309,6 @@ def render_diff(diff_text: str) -> list[str]:
     old_no = new_no = 0
     pending_removed: list[tuple[int, str]] = []
     pending_added: list[tuple[int, str]] = []
-    in_hunk = False
 
     def flush() -> None:
         if len(pending_removed) == 1 and len(pending_added) == 1:
@@ -315,20 +324,18 @@ def render_diff(diff_text: str) -> list[str]:
         pending_removed.clear()
         pending_added.clear()
 
-    for line in diff_text.splitlines():
-        hunk = _HUNK.match(line)
-        if not hunk and not in_hunk:
-            # The ``---``/``+++`` file headers. Skipped by position rather than
-            # by their doubled sign, which also hid every changed line whose own
-            # text starts with ``--`` or ``++`` - a SQL comment, ``++i``.
+    # File headers and anything else between hunks are left out by diff_rows:
+    # the approval or the edit header above already names the file.
+    for row in diff_rows(diff_text):
+        if row.kind == "file":
             continue
-        if hunk:
-            in_hunk = True
+        if row.header is not None:
             flush()
-            old_no, new_no = int(hunk.group(1)), int(hunk.group(3))
+            old_no, new_no = int(row.header.group(1)), int(row.header.group(3))
             if out:
                 out.append(fg("diff_context", ELLIPSIS))
             continue
+        line = row.text
         if line.startswith("-"):
             pending_removed.append((old_no, line[1:].expandtabs(4)))
             old_no += 1
@@ -351,7 +358,7 @@ def looks_like_diff(text: str) -> bool:
     prefix alone meant YAML front matter and a markdown rule were run through
     the diff painter, which strips exactly those lines and emits nothing.
     """
-    return any(_HUNK.match(line) for line in text.splitlines())
+    return any(HUNK_HEADER.match(line) for line in text.splitlines())
 
 
 #: Owned by the tools layer, which produces the diffs. The TUI may depend on
@@ -434,8 +441,7 @@ class WriteRenderer(ToolRenderer):
         header = fg("tool_title", "write ", bold=True) + fg("accent", path)
         content = str(call.params.get("content") or "")
         if content:
-            count = len(content.splitlines())
-            header += fg("dim", f"  {count} line{'s' if count != 1 else ''}")
+            header += fg("dim", f"  {count(len(content.splitlines()), 'line')}")
         return header
 
     def body(self, call: ToolCall) -> list[str]:
@@ -500,7 +506,7 @@ class BashRenderer(ToolRenderer):
         first, rest = self._command_lines(call)
         header = fg("accent", BASH, bold=True) + fg("tool_title", first or ELLIPSIS, bold=True)
         if rest:
-            header += fg("muted", f"  +{len(rest)} line{'s' if len(rest) != 1 else ''}")
+            header += fg("muted", f"  +{count(len(rest), 'line')}")
         if timeout := call.params.get("timeout"):
             header += fg("muted", f" (timeout {timeout}s)")
         if call.params.get("run_in_background"):

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/tui/views/blocks.py

@@ -16,6 +16,7 @@ from collections.abc import Sequence
 from pathlib import Path
 from typing import TYPE_CHECKING, Any
 
+from hx.term.ansi import wrap
 from hx.term.component import Widget
 from hx.term.markdown import render_markdown
 from hx.term.primitives import Box, HangingText, Lines
@@ -155,6 +156,10 @@ def _stream_tail(text: str) -> str:
     return tail[tail.find("\n") + 1 :]
 
 
+BODY_INDENT = 2
+"""Cells a tool block's body sits in from its marker, under the header's text."""
+
+
 class ToolBlock(Widget):
     """One tool call: a header, optionally some output, tinted by its state.
 
@@ -271,9 +276,16 @@ class ToolBlock(Widget):
 
         renderer = renderer_for(self._call.name)
         lines = [fg(marker_role, f"{marker} ") + renderer.header(self._call)]
+        body = renderer.body(self._call)
+        if state == "error":
+            # An error is prose, and wraps like prose. Cut at the edge the way
+            # code is, "<long path> is a link to <long path>, and ... does not
+            # exist" lost exactly the part that said what was wrong.
+            room = max(1, width - 2 - BODY_INDENT)  # the box's padding, then the indent
+            body = [piece for line in body for piece in wrap(line, room)]
         # The body is indented to sit under the header's text rather than under
         # its marker, so the block has one left edge instead of two.
-        lines += [f"  {line}" for line in renderer.body(self._call)]
+        lines += [" " * BODY_INDENT + line for line in body]
         if self._call.interrupted:
             took = self._call.duration_ms
             lines.append(

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/tui/views/permission.py

@@ -184,6 +184,19 @@ class PermissionPrompt(Widget, Framed):
         return [*lines[:PREVIEW_LINES], expand_note(len(lines) - PREVIEW_LINES)]
 
     def _detail_lines(self) -> list[str]:
+        if link := self._link():
+            return [fg("warning", f"{link[0]} is a link to {link[1]}"), "", *self._body_lines()]
+        return self._body_lines()
+
+    def _link(self) -> tuple[str, str] | None:
+        """The path an edit names and the file it really changes, when they differ."""
+        target = getattr(self.request, "link_target", None)
+        path = (self.request.params or {}).get("file_path")
+        if not target or not path:
+            return None
+        return plain_text(display_path(path, self.cwd)), plain_text(display_path(target, self.cwd))
+
+    def _body_lines(self) -> list[str]:
         # Sanitized before anything reads it. This is the one block on screen
         # whose whole job is to show the user what is about to happen, so text
         # that can move the cursor or repaint the line is the last thing it
@@ -216,6 +229,8 @@ class PermissionPrompt(Widget, Framed):
         already knows, and the record is cut before the part they do not.
         """
         specifier = self.request.specifier
+        if link := self._link():
+            return f"{link[0]} → {link[1]}"
         if specifier and specifier == (self.request.params or {}).get("file_path"):
             return plain_text(display_path(specifier, self.cwd))
         return plain_text(str(specifier or self.request.description))

{hx_cli-0.2.17 → hx_cli-0.2.18}/src/hx/tui/views/pickers.py

@@ -21,6 +21,7 @@ from hx.core.usage import format_tokens
 from hx.paths import tilde
 from hx.term.component import Widget
 from hx.term.primitives import Lines, Rule, Spacer, Text
+from hx.text import count
 from hx.tui.format import columns, one_line
 from hx.tui.fuzzy import filter_items
 from hx.tui.glyphs import CURRENT, CURSOR, GUTTER
@@ -344,7 +345,7 @@ class ModelPicker(Picker):
                 (values.index(value) for value in (selected, self.current) if value in values),
                 min(self.selected, max(0, len(values) - 1)),
             )
-            self.status = ("success", f"Refreshed {len(models)} models.")
+            self.status = ("success", f"Refreshed {count(len(models), 'model')}.")
         self.invalidate()
         self._redraw()
 
@@ -578,8 +579,7 @@ def _size(meta: Any) -> str:
     prompts = getattr(meta, "prompt_count", 0)
     if not prompts:
         return f"{meta.message_count} msgs"
-    unit = "prompt" if prompts == 1 else "prompts"
-    return f"{prompts} {unit} · {meta.message_count} msgs"
+    return f"{count(prompts, 'prompt')} · {meta.message_count} msgs"
 
 
 __all__ = [