@tiens.nguyen/gu-cli 1.0.748 → 1.0.750

package/gonext_agent_chat.py

@@ -3813,6 +3813,12 @@ def _normalize_code_tags(text: str) -> str:
          <code> tag is present, so we don't touch backticks inside a real <code> block).
       5. opened-but-never-closed (exactly one "<code>", no "</code>"): append "</code>"
          so the parser can still extract the code instead of failing the whole step.
+      6. NO DELIMITERS AT ALL, but the reply is Python that calls something — an optional
+         "Thought:" line, then e.g. `print(read_file_lines(...))`. Measured on Claude: 13
+         such replies in one turn, each thrown away as "no runnable code block" and re-asked,
+         about a quarter of the turn's steps. Wrapped only when the code (after the Thought
+         line) COMPILES and contains a call — prose does not parse as Python, so a sentence
+         is never mistaken for code.
     Idempotent — already-correct "<code>…</code>" is returned unchanged."""
     if not text:
         return text
@@ -3823,9 +3829,36 @@ def _normalize_code_tags(text: str) -> str:
         fixed = _MD_FENCE_BLOCK.sub(lambda m: f"<code>\n{m.group(1)}</code>", fixed, count=1)
     if fixed.count("<code>") == 1 and "</code>" not in fixed:
         fixed = fixed + "\n</code>"
+    if "<code>" not in fixed and "</code>" not in fixed:
+        bare = _bare_code_block(fixed)
+        if bare is not None:
+            thought, code = bare
+            fixed = (thought + "\n" if thought else "") + "<code>\n" + code + "\n</code>"
     return fixed
 
 
+def _bare_code_block(text: str):
+    """(thought, code) when `text` is Python with no delimiters — an optional leading
+    "Thought: …" line, then code that compiles and calls something. Else None."""
+    import ast
+    t = (text or "").strip()
+    if not t:
+        return None
+    thought = ""
+    lines = t.splitlines()
+    if lines and lines[0].lstrip().lower().startswith("thought:"):
+        thought, t = lines[0].strip(), "\n".join(lines[1:]).strip()
+    if not t:
+        return None
+    try:
+        tree = ast.parse(t)
+    except SyntaxError:
+        return None
+    if not any(isinstance(n, ast.Call) for n in ast.walk(tree)):
+        return None
+    return thought, t
+
+
 def _escape_raw_newlines_in_strings(code: str, defuse_tags: bool = False) -> str:
     """Turn RAW newlines/tabs that sit INSIDE a single/double-quoted string literal into
     \\n/\\t escapes. Triple-quoted strings, comments, and everything outside a string are
@@ -8020,13 +8053,19 @@ def run_agent_chat(cfg):
         # ORDER to use them in and the CONSTRAINTS that bite — so keep those, drop the third
         # retelling. Every rule below is a scar: token waste (#63/#79), no-shell/no-sudo,
         # key-only deploys (#57).
-        "    THE EDIT LOOP: grep_repo to LOCATE → read_file_lines around the hit (a SMALL "
-        "range; never re-read the whole file or the same range twice — large reads are "
-        "truncated and slow every later step) → edit_lines to change it → run_command to "
-        "VERIFY. edit_file only for a byte-exact unique string; create_file(overwrite=True) "
+        # Task #48 (GitHub): string edits are the default, like Claude Code's Edit tool. A
+        # line-number edit needs a fresh read before every edit (each one shifts the numbers):
+        # a measured turn spent 12 of its 43 steps on read → edit_lines → read → edit_lines.
+        "    THE EDIT LOOP: LOCATE (explore, grep_repo) → read_file_lines ONCE around what you will "
+        "change (a SMALL range; never re-read the whole file or the same range twice) → make ALL "
+        "of that file's edits in ONE block with edit_file(path, old_string, new_string), quoting "
+        "a short UNIQUE snippet from what you read — no line numbers, so no re-read between "
+        "edits → VERIFY with run_command (in the same block when you can). edit_lines only when "
+        "you cannot quote a unique string (e.g. replacing a long range); create_file(overwrite=True) "
         "replaces a whole file in ONE call (no read+edit just to rewrite it).\n"
-        "    EXPLORE FIRST — before CHANGING code you have not seen yet in this conversation, and "
-        "for any broad question (where is X handled, how does Y work, what would a change to Z "
+        "    EXPLORE FIRST — before CHANGING code you have not seen yet in this conversation "
+        "(always for a change that spans several files or layers — frontend + backend, UI + API), "
+        "and for any broad question (where is X handled, how does Y work, what would a change to Z "
         "touch): call explore(question) ONCE to map the files and lines involved. It searches in "
         "a SEPARATE context and returns a short summary with path:line references, so its greps "
         "and reads do not pile up here and are not re-sent on every later step. Then read only "
@@ -8071,12 +8110,11 @@ def run_agent_chat(cfg):
         "- user asks to FIX A BUG / MODIFY / ADD CODE in a workspace -> "
         "grep_repo(pattern) when you know the exact string, or rag_search_workspace(query) "
         "when you do not, to FIND the file, THEN "
-        "read_file_lines(file, around the hit) to see exact lines, THEN "
-        "edit_lines(file, start, end, new_content) to change them, THEN "
+        "read_file_lines(file, around the hit) ONCE, THEN edit_file(file, old_string, new_string) "
+        "for EACH change to that file — all in ONE block —, THEN "
         "run_command('…test…') to VERIFY if run permission exists — read failures and fix, "
         "iterate. Finish with final_answer summarizing WHAT you changed (files + lines). "
-        "AFTER editing, re-read with grep_repo/read_file_lines (an indexed knowledge base may be "
-        "stale — do not trust rag_search for freshly edited code).\n"
+        "Do not trust rag_search for freshly edited code (the index may be stale).\n"
     ) if _WS_AVAILABLE else ""
     _email_choose_line = (
         "- 'email …' / 'send an email to …' -> send_email(to, subject, body) "
@@ -8261,7 +8299,8 @@ def run_agent_chat(cfg):
         + ("Remember: FINISH what was asked yourself — fix blockers, VERIFY the outcome, then "
            "final_answer with evidence; never hand the task back. If it only asks to RECORD work "
            "(create a task, a note, a plan), recording it IS the task — do not start the work. "
-           "To change code you have not seen yet, map it with ONE explore() call first.\n"
+           "To change code you have not seen yet — especially across several files — map it with "
+           "ONE explore() call first, then make each file's edits in ONE block with edit_file.\n"
            if _WS_AVAILABLE else "")
         + "\nTASK (answer THIS, choose the tool that fits it):\n"
         f"{task_text}\n"
@@ -10304,7 +10343,11 @@ def run_agent_chat(cfg):
                         r"send_email)\s*\("
                     )
                     fence_is_toolcall = any(re.search(_tool_call_re, b) for b in fence_bodies)
-                    if has_code_tag or fence_is_toolcall:
+                    # Bare Python with no delimiters at all (case 6 of _normalize_code_tags) —
+                    # it used to fall through to the prose branch and cost a whole step.
+                    bare_code = (not has_code_tag and not fence_bodies
+                                 and _bare_code_block(content) is not None)
+                    if has_code_tag or fence_is_toolcall or bare_code:
                         normalized = _normalize_code_tags(content)
                         if normalized != content:
                             _log("normalized code-block tags (<code >/fence → <code>)")
@@ -10456,13 +10499,16 @@ def run_agent_chat(cfg):
         # from the prompt, not writing code. Deliberately carries NO literal delimiter (the
         # system prompt already shows the format with a worked example), so there is nothing
         # to echo. Applied only when kind=openai; Ollama keeps the stock message.
+        # STRONG MODELS (2026-09-25): the delimiters are named again. Leaving them out was a
+        # workaround for Kimi echoing them; on Claude it did the opposite — told to use "the
+        # delimiters shown in the system prompt", it replied with bare code, which failed the
+        # same way, 13 times in one turn. And "call exactly one tool" contradicted batching.
         _PARSE_ERROR_REPLACEMENT = (
             "Error: your last reply contained no runnable code block, so nothing executed "
             "and no observation was produced.\n"
-            "Reply with ONE 'Thought:' line, then the code block using the exact opening and "
-            "closing delimiters shown in the system prompt, with ONLY Python between them — "
-            "no prose inside the block, and do not repeat these instructions back to me. "
-            "Call exactly one tool, or call final_answer(...) if you are done."
+            "Reply with ONE 'Thought:' line, then your Python between <code> and </code> — "
+            "nothing else inside the block. Batch independent calls as usual, or call "
+            "final_answer(...) if you are done."
         )
 
         def _sanitize_parse_errors(self, msgs):
@@ -11601,7 +11647,7 @@ def run_agent_chat(cfg):
 
         @tool
         def edit_lines(path: str, start_line: int, end_line: int, new_content: str) -> str:
-            """Replace lines start_line..end_line (inclusive, 1-based) of a workspace file with new_content. The PRIMARY edit tool — get exact line numbers from grep_repo/read_file_lines first. A backup is saved automatically.
+            """Replace lines start_line..end_line (inclusive, 1-based) of a workspace file with new_content. Use it only when you cannot quote a unique string for edit_file (e.g. replacing a long range). Line numbers shift after every edit, so re-read before another edit_lines in the same file. A backup is saved automatically.
 
             Args:
                 path: file inside a registered workspace.
@@ -11658,7 +11704,7 @@ def run_agent_chat(cfg):
 
         @tool
         def edit_file(path: str, old_string: str, new_string: str) -> str:
-            """Replace an EXACT unique text occurrence in a workspace file (must match byte-for-byte incl. whitespace). Prefer edit_lines when you have line numbers. A backup is saved automatically.
+            """The PRIMARY edit tool: replace an EXACT, unique text occurrence in a workspace file (byte-for-byte, incl. whitespace). It needs no line numbers, so several edit_file calls to one file go in ONE block after a single read. A backup is saved automatically.
 
             Args:
                 path: file inside a registered workspace.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.748",
+  "version": "1.0.750",
   "description": "Gu CLI — the gu terminal plus the local worker that runs agent / OCR / PDF / embedding jobs on your Mac (Ollama / MLX / OpenAI-compatible).",
   "type": "module",
   "license": "MIT",