hexcli 2.16.0__tar.gz → 2.18.0__tar.gz

{hexcli-2.16.0 → hexcli-2.18.0}/CHANGELOG.md

@@ -4,6 +4,73 @@ 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.18.0 — 2026-09-18
+
+A minor release: what `write_file` writes for one shape of body changes,
+so the run that follows it changes.
+
+> **Gate: PASS** on the pinned 24-case set after rechecks. Own arm, fresh
+> server, seed 20260918, 2 invalid of 245 runs. `agentic-5` and
+> `error-recovery-3` (a counting answer and a denied search, no write in
+> either) missed once at 5 runs; `agentic-5` held 6/6, `error-recovery-3`
+> read 3/4 with two invalid runs on a server 70 minutes into its traffic and
+> 6/6 on a fresh one. Against the v2.11.1 12-run baseline: run-level
+> 402/514 vs 182/228, +1.6 %, Fisher p = 0.70; pass^k 26 → 29 of 46 shared
+> cases, McNemar p = 0.51. The unescape fired on three writes in the arm
+> (a `trap-1` poem and two `runit-1` bodies, all of which decode the same
+> under both rules), so the arm is evidence of no regression and the effect
+> rests on the fixture. Smoke 10/10 on a fresh server.
+
+- A double-escaped Python body is decoded the way that parses. The model
+  writes its line breaks as literal `\n` when it escapes a reply twice, and
+  the `\n` it means as a string escape inside the code looks exactly the
+  same: `print(\"\nWelcome\")` and the line break after it are the same two
+  characters. The 2.9.0 rule decoded all of them, so on 2026-09-18 the owner
+  got a file that read `print("` on one line and `Welcome to the Calculator
+  App!")` on the next, and the model spent the rest of the session not
+  fixing it. For a `.py` path the body is now decoded in full and parsed; if
+  that fails, every `\n` except one sitting right after an opening quote or
+  right before a closing one is decoded and the result parsed again, and
+  whichever parses is written (the full decode when neither does, as
+  before). Other file types are unchanged. Of the 511 `write_file` bodies on
+  record five are double-escaped, two have a quote-adjacent `\n`, and one of
+  those, the session above, parses only this way.
+
+## 2.17.0 — 2026-09-18
+
+A minor release: the parser accepts a reply it used to send back for a
+retry, so what the model sees after such a reply changes.
+
+> **Gate: PASS** on the pinned 24-case set, all 24 held at 5 runs with no
+> recheck. Own arm, fresh server, seed 20260918, 6 invalid of 245 runs.
+> Against the v2.11.1 12-run baseline: run-level 402/514 vs 174/224, −0.5 %,
+> Fisher p = 0.92; pass^k 26 → 31 of 46 shared cases, McNemar p = 0.13. The
+> close fired on five replies in the arm (`claims-1`, `claims-2`, two in
+> `tests-claim-1`, one in `trap-3`); `claims-1` 3/5 against 3/11, `trap-3`
+> 0/5 as before. Smoke 9/10 on a fresh server; the miss was `factual-1`,
+> re-measured 7/10 against its recorded 79 % (p = 0.67).
+
+- A reply that stops before its last closing brace is closed and decoded.
+  In the owner's 2026-09-18 session two `write_file` replies, 2,239 and 782
+  characters, ended at `"}` with the outer object never closed. The parser's
+  stray-quote repair took the decoder's "Expecting ',' delimiter" at the end
+  of the text as a quote that had ended a string early, escaped the
+  content's own closing quote, and the decoder then reported an unterminated
+  string; the retry feedback told the model to fix its quoting, the model
+  escaped everything twice, and the file it wrote had `\n` and `\"` in it as
+  text. Every step after that in the session was the model failing to repair
+  that file. When the decoder's error sits at the very end of the reply,
+  every string is closed and the brace depth is still positive, the missing
+  braces are appended and the object decodes. Measured over the 10,772
+  replies on record: 185 fail to decode, and 27 of them now decode (all one
+  brace short; 23 in `claims-1`, `claims-2` and `tests-claim-1`, four in the
+  owner's sessions). The close is only tried on the reply as sent: three
+  more replies are a brace short *after* a stray quote, and a reply whose
+  content string was cut off and then followed by a second object would
+  otherwise be glued into one, so those stay retries. A reply cut off inside
+  a string is still reported as cut off, and a stray quote in the middle is
+  still repaired as before; the other 158 undecodable replies are unchanged.
+
 ## 2.16.0 — 2026-09-18
 
 A minor release: a tool result the model reads changes (`find_files` returns

{hexcli-2.16.0 → hexcli-2.18.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: hexcli
-Version: 2.16.0
+Version: 2.18.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.16.0 → hexcli-2.18.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.16.0"
+__version__ = "2.18.0"

{hexcli-2.16.0 → hexcli-2.18.0}/hexcli/editing.py

@@ -12,6 +12,7 @@ audit (2026-07) through the merge tier (2026-09-13).
 """
 from __future__ import annotations
 
+import ast
 import difflib
 import re
 
@@ -140,6 +141,45 @@ def unescape_json(text: str) -> str:
     return _unescape_json(text)
 
 
+_QUOTE_ADJACENT_NL = re.compile(r'(["\'])\\n|\\n(["\'])')
+
+
+def unescape_body(text: str, path: str) -> str:
+    """Decode a double-escaped file body, keeping a Python source parseable.
+
+    A body the model escaped twice carries its line breaks as literal \\n --
+    and so does every \\n it meant as a string escape inside the code:
+    `print(\\"\\nWelcome\\")` and the line break after it are the same two
+    characters. Decoding all of them (the 2.9.0 rule) turns the escape into a
+    real newline inside the string literal, and the file the owner got on
+    2026-09-18 read `print("` / `Welcome to the Calculator App!")` -- a
+    SyntaxError the model then spent eleven steps not fixing.
+
+    For a .py path, decode everything and parse; if that fails, decode
+    everything EXCEPT a \\n that sits right after an opening quote or right
+    before a closing one, and parse again; keep whichever parses, and the
+    full decode when neither does (the caller's checker will say so). Other
+    file types get the full decode as before. Measured over the 511
+    write_file bodies on record: five are double-escaped, two of those have
+    a quote-adjacent \\n, and one of the two (the session above) parses only
+    this way."""
+    full = _unescape_json(text)
+    if not path.lower().endswith(".py"):
+        return full
+    try:
+        ast.parse(full)
+        return full
+    except SyntaxError:
+        pass
+    kept = _QUOTE_ADJACENT_NL.sub(lambda m: (m.group(1) or "") + "\x00" + (m.group(2) or ""), text)
+    candidate = _unescape_json(kept).replace("\x00", "\\n")
+    try:
+        ast.parse(candidate)
+        return candidate
+    except SyntaxError:
+        return full
+
+
 _DELTA_TOKEN_RE = re.compile(r"\w+|\s+|[^\w\s]")
 _ESCAPED_RE = re.compile(r'\\["nt\\]')
 _BARE_QUOTE_RE = re.compile(r'(?<!\\)"')

{hexcli-2.16.0 → hexcli-2.18.0}/hexcli/parsing.py

@@ -126,6 +126,49 @@ def _repair_stray_quote(text: str, err: json.JSONDecodeError) -> str | None:
     return text[:q] + "\\" + text[q:]
 
 
+def _close_unfinished_object(text: str, start: int, err: json.JSONDecodeError) -> str | None:
+    """The reply ended before its last closing brace(s): `{"action":"write_file",
+    "args":{...,"content":"..."}` and then nothing. The decoder reports
+    "Expecting ',' delimiter" AT THE END of the text; every string is closed
+    and the brace depth is still positive. Appending the missing braces is
+    the whole repair. 30 of the 185 undecodable replies on record are this
+    shape, all one brace short, four of them in the owner's sessions
+    (2026-09-13 and 2026-09-18), and the stray-quote repair below used to
+    make them worse: it escaped the content's own closing quote, the decoder
+    then said "Unterminated string", and the retry feedback told the model
+    to fix its quoting -- which it did by escaping everything twice, and the
+    file it then wrote had backslashes in it. None when the error is not at
+    the end, a string is still open, or the braces already balance."""
+    if err.pos < len(text.rstrip()):
+        return None
+    depth, in_string, escaped = 0, False, False
+    for ch in text[start:]:
+        if in_string:
+            if escaped:
+                escaped = False
+            elif ch == "\\":
+                escaped = True
+            elif ch == '"':
+                in_string = False
+        elif ch == '"':
+            in_string = True
+        elif ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+    if in_string or depth <= 0:
+        return None
+    return text.rstrip() + "}" * depth
+
+
+# Only the reply AS SENT is closed this way. Once a stray-quote repair has
+# changed the text, a positive depth at the end can be the repair's own
+# doing (a write whose content string was cut off, followed by a second
+# object: the repairs walk the quotes back until the text "balances" and
+# the close would then glue the two objects into one), and that reply must
+# stay a retry -- evals/test_backports.py pins it.
+
+
 def _loads_object(text: str) -> dict[str, Any] | None:
     """The first JSON object in `text`, decoded from its first brace and
     ignoring whatever follows it (a second batched action, prose). Stray
@@ -133,12 +176,13 @@ def _loads_object(text: str) -> dict[str, Any] | None:
     start = text.find("{")
     if start < 0:
         return None
-    for _ in range(_MAX_QUOTE_REPAIRS + 1):
+    for attempt in range(_MAX_QUOTE_REPAIRS + 1):
         try:
             parsed, _end = _DECODER.raw_decode(text, start)
             return parsed if isinstance(parsed, dict) else None
         except json.JSONDecodeError as err:
-            fixed = _repair_stray_quote(text, err)
+            fixed = (_close_unfinished_object(text, start, err) if attempt == 0 else None) \
+                or _repair_stray_quote(text, err)
             if fixed is None:
                 return None
             text = fixed
@@ -155,13 +199,14 @@ def _decode_failure(text: str) -> tuple[json.JSONDecodeError | None, str]:
     if start < 0:
         return None, text
     last: json.JSONDecodeError | None = None
-    for _ in range(_MAX_QUOTE_REPAIRS + 1):
+    for attempt in range(_MAX_QUOTE_REPAIRS + 1):
         try:
             _DECODER.raw_decode(text, start)
             return None, text
         except json.JSONDecodeError as err:
             last = err
-            fixed = _repair_stray_quote(text, err)
+            fixed = (_close_unfinished_object(text, start, err) if attempt == 0 else None) \
+                or _repair_stray_quote(text, err)
             if fixed is None:
                 return err, text
             text = fixed

{hexcli-2.16.0 → hexcli-2.18.0}/hexcli/tools.py

@@ -461,7 +461,7 @@ def write_file_tool(path_text: str, content: str) -> str:
     path.parent.mkdir(parents=True, exist_ok=True)
     note = ""
     if p2.looks_double_escaped(content):
-        content = p2.unescape_json(content)
+        content = p2.unescape_body(content, str(path))
         note = ", unescaped"
     tmp = path.parent / (path.name + ".tmp")
     tmp.write_text(content, encoding="utf-8")