hexcli 2.21.0__tar.gz → 2.22.1__tar.gz

{hexcli-2.21.0 → hexcli-2.22.1}/CHANGELOG.md

@@ -4,6 +4,44 @@ Full evidence for every claim below — including the experiments that failed
 lives in `docs/V2_PLAN.md` §14. Numbers are pass^k over repeated live runs on
 the Hexagon NPU, not single-run anecdotes.
 
+## 2.22.1 — 2026-10-10
+
+A patch release: only the eval harness changes.
+
+- `python evals/cases_smoke.py` runs ten cases from the pinned gate set
+  (`SMOKE_SET`) instead of its own ten. The old set held `factual-1` (19/24),
+  `agentic-2` (18/24), `agentic-3` (18/20) and `lint-1` (20/21), so
+  unchanged code scored 10/10 about half the time and most releases
+  re-measured one of them. Each of the new ten passed every run in the two
+  arms that pinned the gate set and in the 16 arms since (44–51 runs each).
+  The new set went 10/10 on its first live run. The extended suite is
+  unchanged.
+
+## 2.22.0 — 2026-10-10
+
+A minor release: a tool result the model reads changes (`edit_file` when
+`new_string` carries a literal `\n` and the file would not parse).
+
+> **Gate: PASS** on the pinned 24-case set after one recheck: `agentic-1`
+> had all five runs invalid ("backend unreachable", the server stalled when
+> free memory hit 1.4 GB), and re-run on a fresh server it was 6/6. Own arm,
+> seed 20261011, against 2.21.0's arm: run-level 184/234 vs 186/233,
+> −1.2 %, Fisher p = 0.82; pass^k 34 → 32 of 49, McNemar p = 0.73; 11
+> invalid runs of 245. The decode never fired in the arm: none of its 48
+> `edit_file` calls had a literal `\n` in `new_string`, so every edit result
+> was byte-identical to 2.21.0 and the arm-level movement is run-to-run
+> noise. The gate shows nothing broke; the benefit is not yet measured live.
+
+- When an edit to a `.py` or `.json` file would leave it unparseable and
+  `new_string` has a literal `\n` but no real line break, `edit_file` tries
+  the decoded `new_string` (the full decode, then for Python one that keeps a
+  quote-adjacent escape) and keeps it only if the file then parses. 139 of
+  1,746 recorded `edit_file` calls put a literal `\n` in `new_string`, 135
+  with no real line break, mostly in `self-correct-1`, `agentic-3` and
+  `regression-anchor-1`, and the 2.21.0 arm lost a run of each of the latter
+  two to it. An escape that parses as written is never touched, and other
+  file types are left alone.
+
 ## 2.21.0 — 2026-10-10
 
 A minor release: a tool result the model reads changes (`edit_file` when

{hexcli-2.21.0 → hexcli-2.22.1}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hexcli
-Version: 2.21.0
+Version: 2.22.1
 Summary: Local Hexagon NPU terminal agent for Snapdragon X Elite Windows ARM64
 Project-URL: Homepage, https://github.com/NathanL15/Hex-CLI
 Project-URL: Repository, https://github.com/NathanL15/Hex-CLI

{hexcli-2.21.0 → hexcli-2.22.1}/hexcli/__init__.py

@@ -3,4 +3,4 @@
 # The one place the version is written. pyproject.toml reads it (hatch
 # dynamic version), agent.VERSION re-exports it, and CI refuses a release
 # tag that does not match it.
-__version__ = "2.21.0"
+__version__ = "2.22.1"

{hexcli-2.21.0 → hexcli-2.22.1}/hexcli/editing.py

@@ -14,6 +14,7 @@ from __future__ import annotations
 
 import ast
 import difflib
+import json
 import re
 
 # Tier that landed the most recent successful block: "exact", "whitespace",
@@ -180,6 +181,45 @@ def unescape_body(text: str, path: str) -> str:
         return full
 
 
+def escaped_new_string_candidates(new_string: str, path: str) -> list[str]:
+    """Decoded forms of an edit's new_string, when it carries its line breaks
+    as literal \\n and has no real one -- the shape of a JSON argument the
+    model escaped twice. Same order as unescape_body: the full decode, then,
+    for a .py path, the one that keeps a quote-adjacent \\n as an escape.
+    The caller keeps a candidate only when the whole file then parses and the
+    edit as written did not, so `print("a\\nb")` is never touched.
+
+    139 of 1,746 recorded edit_file calls (2026-10-10) carry this shape, 135
+    of them with no real line break; on .py, 73 of 82 parse only decoded
+    (self-correct-1's `def add(a, b):\\n    return a + b`)."""
+    if "\n" in new_string or "\\n" not in new_string:
+        return []
+    full = _unescape_json(new_string)
+    out = [full]
+    if path.lower().endswith(".py"):
+        kept = _QUOTE_ADJACENT_NL.sub(
+            lambda m: (m.group(1) or "") + "\x00" + (m.group(2) or ""), new_string)
+        candidate = _unescape_json(kept).replace("\x00", "\\n")
+        if candidate != full:
+            out.append(candidate)
+    return out
+
+
+def file_parses(text: str, path: str) -> bool | None:
+    """Whether a .py or .json file's text parses; None for other types."""
+    suffix = path.lower().rsplit(".", 1)[-1] if "." in path else ""
+    try:
+        if suffix == "py":
+            ast.parse(text)
+        elif suffix == "json":
+            json.loads(text)
+        else:
+            return None
+    except (SyntaxError, ValueError):
+        return False
+    return True
+
+
 _DELTA_TOKEN_RE = re.compile(r"\w+|\s+|[^\w\s]")
 _ESCAPED_RE = re.compile(r'\\["nt\\]')
 _BARE_QUOTE_RE = re.compile(r'(?<!\\)"')

{hexcli-2.21.0 → hexcli-2.22.1}/hexcli/tools.py

@@ -435,22 +435,39 @@ def edit_file_tool(path_text: str, old_string: str, new_string: str) -> str:
             "Put the changed text in new_string, or read_file to see what is there now."
         )
     content = path.read_text(encoding="utf-8")
-    tier = "exact"
-    if content.count(old_string) == 1:
-        new_content = content.replace(old_string, new_string, 1)
-    else:
-        new_content, err = apply_search_replace(content, [(old_string, new_string)])
+
+    def _apply(replacement: str) -> tuple[str, str]:
+        if content.count(old_string) == 1:
+            return content.replace(old_string, replacement, 1), "exact"
+        out, err = apply_search_replace(content, [(old_string, replacement)])
         if err:
             if err.startswith("SEARCH block 1 was not found") and len(content) <= _WHOLE_FILE_ON_MISS:
                 raise RuntimeError(_not_found_with_content(path, content))
             raise RuntimeError(err.replace("SEARCH block 1", "old_string"))
-        tier = p2.LAST_APPLY_TIER
+        return out, p2.LAST_APPLY_TIER
+
+    new_content, tier = _apply(new_string)
+    # A new_string the model escaped twice puts a literal \n into the file
+    # (self-correct-1, regression-anchor-1: "unexpected character after line
+    # continuation"). Decode it only when the file as written does not parse
+    # and the decoded edit does; a genuine escape always parses as written.
+    if p2.file_parses(new_content, str(path)) is False:
+        for candidate in p2.escaped_new_string_candidates(new_string, str(path)):
+            try:
+                decoded_content, decoded_tier = _apply(candidate)
+            except RuntimeError:
+                continue
+            if p2.file_parses(decoded_content, str(path)):
+                new_content, new_string = decoded_content, candidate
+                tier = "unescaped" if decoded_tier == "exact" else f"{decoded_tier} match, unescaped"
+                break
     tmp = path.parent / (path.name + ".tmp")
     tmp.write_text(new_content, encoding="utf-8")
     tmp.replace(path)
     delta = new_string.count("\n") - old_string.count("\n")
     # The tier is UI-only (arm logs read it); the model sees "Edited <path>".
-    suffix = "" if tier == "exact" else f", {tier} match"
+    suffix = ("" if tier == "exact" else f", {tier}" if "unescaped" in tier
+              else f", {tier} match")
     ui.tool_event("edit", f"{path}  ({delta:+d} lines{suffix})")
     return f"Edited {path}"