hexcli 2.20.1__tar.gz → 2.22.0__tar.gz

{hexcli-2.20.1 → hexcli-2.22.0}/CHANGELOG.md

@@ -4,6 +4,60 @@ 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.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
+`old_string` is not in the file).
+
+> **Gate: PASS** on the pinned 24-case set after one recheck:
+> `error-recovery-3` missed one of five runs, and that run never called
+> `edit_file` (it reported a "permission error" after `find_files`); re-run on
+> a fresh server it was 6/6. Own arm, seed 20261010, against 2.20.0's arm:
+> run-level 189/237 vs 192/245, +1.4 %, Fisher p = 0.74; pass^k 32 → 34 of
+> 49, McNemar p = 0.73; 8 invalid runs of 245 (backend timeouts, 2.2 GB
+> free). `claims-2`, one of the three cases behind most of the recorded
+> misses, went 2/5 → 5/5. `self-correct-1` lost one run to the known
+> double-escaped `new_string` (a literal `\n` landed on the first edit,
+> before any miss), and `regression-anchor-1` lost one to the same defect
+> with no miss at all. Smoke 9/9 valid on a fresh server.
+
+- A missed `edit_file` on a file of up to 1,500 characters returns the
+  file's whole current text instead of the closest region. Of 1,279 recorded
+  `edit_file` calls, 786 were made without reading the file that turn and
+  failed 45 % of the time against 9 % after a read, and 115 of the 291
+  misses came straight after another miss on the same file: the retry was
+  rebuilt from memory again. Every fixture behind those misses is under 200
+  characters. In the arm the message fired 16 times, in `tests-claim-1`,
+  `self-correct-1`, `claims-2` and `agentic-3`, and the next edit landed
+  after 7 of them (44 %), against 14 of 39 (36 %) in the three arms before
+  it; at that count the recovery rate is not yet a measured effect. A larger
+  file keeps the closest-region report.
+
 ## 2.20.1 — 2026-10-10
 
 A patch release: nothing the model reads changes. The turn's return value

{hexcli-2.20.1 → hexcli-2.22.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hexcli
-Version: 2.20.1
+Version: 2.22.0
 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.20.1 → hexcli-2.22.0}/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.20.1"
+__version__ = "2.22.0"

{hexcli-2.20.1 → hexcli-2.22.0}/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.20.1 → hexcli-2.22.0}/hexcli/tools.py

@@ -435,24 +435,63 @@ 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}"
 
 
+# A missed edit_file on a small file gets the file's whole text back instead of
+# the closest region. Of 1,279 recorded edit_file calls (2026-09-18), 786 were
+# made without reading or writing the file that turn and failed 45 % of the
+# time against 9 % after a read, and 115 of the 291 misses came straight after
+# another miss on the same file: the retry was rebuilt from memory again. With
+# the text in the error the retry can be copied from the file, at no extra
+# step. Every fixture behind those misses is under 200 characters; a file
+# above the cap keeps the closest-region report.
+_WHOLE_FILE_ON_MISS = 1500
+
+
+def _not_found_with_content(path: Path, content: str) -> str:
+    body = content if content.strip() else "(the file is empty)"
+    return (
+        f"old_string was not found in {path}. This is the file's whole current "
+        "content; copy the lines to change from it exactly into old_string:\n"
+        f"---\n{body.rstrip(chr(10))}\n---"
+    )
+
+
 def write_file_tool(path_text: str, content: str) -> str:
     from . import editing as p2