@tiens.nguyen/gu-cli 1.0.829 → 1.0.831

package/gonext_agent_chat.py

@@ -5109,6 +5109,46 @@ def _repair_unterminated_string(code: str) -> str:
         return code
 
 
+# A COMMIT MESSAGE IN A SHELL LINE IN A PYTHON STRING (#360 follow-up). The model passes run_command
+# a whole `git commit -F - <<'EOF' … EOF` (or -m "…") as ONE normal "…" string. The message has
+# line breaks AND, often, the string's own quote ('"node /opt/…/gu"', "turn's") — so the literal
+# ends early and escaping newlines cannot help. Measured 2026-10-14: 2 of the last 2 commit turns
+# lost a step to exactly this. The command argument runs from the call's opening quote to the
+# LAST matching quote that is followed by the next argument or the closing paren; re-quoted as a
+# triple-quoted string it is the text the model meant. Kept only when the block then compiles.
+_RUN_CMD_OPEN_RE = re.compile(r"\brun_command\(\s*(?:command\s*=\s*)?(['\"])(?!\1\1)")
+
+
+def _repair_run_command_string(code: str) -> str:
+    try:
+        compile(code, "<gu-code>", "exec")
+        return code
+    except SyntaxError:
+        pass
+    except Exception:  # noqa: BLE001
+        return code
+    m = _RUN_CMD_OPEN_RE.search(code)
+    if not m:
+        return code
+    q, start = m.group(1), m.end()
+    closer = re.compile(re.escape(q) + r"(?=\s*(?:,\s*(?:workdir|timeout_seconds|background)\s*=|,\s*['\"]|\)))")
+    next_arg = re.compile(re.escape(q) + r"\s*,\s*(?:workdir|timeout_seconds|background)\s*=")
+    for end in reversed([x.start() for x in closer.finditer(code, start)]):
+        body = code[start:end]
+        if next_arg.search(body):
+            continue  # it swallowed the next argument — the command ends earlier
+        for wrap in ('"""', "'''"):
+            if wrap in body or body.endswith(wrap[0]):
+                continue
+            fixed = code[:m.start(1)] + wrap + body + wrap + code[end + 1:]
+            try:
+                compile(fixed, "<gu-code>", "exec")
+                return fixed
+            except SyntaxError:
+                continue
+    return code
+
+
 def _repair_code_block_strings(text: str) -> str:
     """Apply _repair_unterminated_string to the python inside a <code>…</code> block
     (leaving the surrounding Thought prose untouched). No-op when there's no block or the
@@ -5134,6 +5174,8 @@ def _repair_code_block_strings(text: str) -> str:
     close_start = open_end + cm.start()
     inner = text[open_end:close_start]
     fixed = _repair_unterminated_string(inner)
+    if fixed == inner:
+        fixed = _repair_run_command_string(inner)
     if fixed != inner:
         return text[:open_end] + fixed + text[close_start:]
     # Stage 2 — only worth trying when there's MORE than one </code> (extra tags in content).
@@ -7950,6 +7992,123 @@ _BG_LINE = ("A LONG job (build, deploy, big test run) → run_command(…, backg
             "timeout moves to the background by itself instead of being killed.\n")
 
 
+# What to do instead, said where quoting broke — in gu's own pre-check (an unbalanced quote never
+# reaches bash) and in bash's error. In a commit turn the next step was otherwise a guess.
+_HEREDOC_HINT = ("\n\nSHELL QUOTING broke this line. For text with quotes or line breaks (a commit "
+                 "message, an issue body) use a heredoc inside a triple-quoted string: "
+                 "run_command(\"\"\"git commit -F - <<'EOF'\n<message>\nEOF\"\"\") — nothing in the "
+                 "message needs escaping.")
+
+# A PIPE HIDES THE EXIT CODE OF EVERYTHING BEFORE IT (#360 review, turn 3c06654e). The model ran
+# `python3 -m pytest … | tail -5 && git add … && git commit …`; pytest was not installed, `tail`
+# exited 0, and the commit went in untested. Global `set -o pipefail` would fix that and break
+# `git log | head -5` (SIGPIPE → 141) everywhere, so the line runs as written and gu READS the
+# output instead: a pipe line that exited 0 while printing an unmistakable failure is reported
+# as one. Markers are line-anchored and specific, so ordinary output containing "error" passes.
+_PIPE_FAIL_RE = re.compile(
+    r"^.*(?:No module named \S+|ModuleNotFoundError: .*|: command not found|: not found$"
+    r"|^Traceback \(most recent call last\):|^fatal: .*|^error: .*|^npm ERR! .*"
+    r"|^E: Unable to locate package .*|: No such file or directory$)",
+    re.M)
+
+
+def _pipe_hidden_failure(scan, out: str) -> str:
+    """The failure line a pipe hid, or "" — only for a line that has a `|`."""
+    if not scan or not any(t[0] == "op" and t[1] == "|" for t in scan.get("tokens") or []):
+        return ""
+    m = _PIPE_FAIL_RE.search(out or "")
+    return m.group(0).strip()[:200] if m else ""
+
+
+def _pipe_hidden_failure_note(line: str) -> str:
+    return ("\n\nWARNING — A FAILURE WAS HIDDEN BY A PIPE: the output shows "
+            f"'{line}', but a pipeline reports only its LAST command's exit code, so this "
+            "line counted as success and every part after `&&` RAN ANYWAY. Check what those "
+            "parts did before relying on them. To chain on a check, run it without a pipe, or "
+            "start the line with `set -o pipefail;`.")
+
+
+# THE PROJECT'S OWN TEST COMMANDS (#360 review). The model guessed `python3 -m pytest` in a repo
+# whose package.json says `python3 -m unittest discover tests -v && node --test` — pytest was not
+# even installed. The manifests already say how each part of the project is tested; reading them
+# costs no tool call. Depth ≤ 3 (a monorepo's packages), at most 8, nearest first.
+_TEST_SKIP_DIRS = {"node_modules", "dist", "build", "out", "target", "vendor", "venv", ".venv",
+                   "__pycache__", "server-bundle", "coverage"}
+
+
+def _project_test_commands(root: str, max_depth: int = 3, limit: int = 8) -> list:
+    """[(relative folder, command)] from package.json scripts.test, a Makefile `test:` target,
+    pytest config, Cargo.toml and go.mod. Never raises."""
+    import json as _json
+    found = []
+    try:
+        root = os.path.abspath(root)
+    except Exception:  # noqa: BLE001
+        return []
+    queue = [(root, 0)]
+    while queue and len(found) < limit:
+        d, depth = queue.pop(0)
+        try:
+            names = set(os.listdir(d))
+        except OSError:
+            continue
+        rel = os.path.relpath(d, root)
+        rel = "." if rel == "." else rel.replace(os.sep, "/")
+        cmd = ""
+        if "package.json" in names:
+            try:
+                with open(os.path.join(d, "package.json"), encoding="utf-8") as fh:
+                    t = ((_json.load(fh) or {}).get("scripts") or {}).get("test") or ""
+                if t and "no test specified" not in t:
+                    cmd = f"npm test  ({_clip(t, 110)})"
+            except Exception:  # noqa: BLE001
+                pass
+        if not cmd and "Makefile" in names:
+            try:
+                with open(os.path.join(d, "Makefile"), encoding="utf-8", errors="replace") as fh:
+                    if re.search(r"(?m)^test\s*:", fh.read(200_000)):
+                        cmd = "make test"
+            except OSError:
+                pass
+        if not cmd and ("pytest.ini" in names or "conftest.py" in names):
+            cmd = "python3 -m pytest"
+        if not cmd and "pyproject.toml" in names:
+            try:
+                with open(os.path.join(d, "pyproject.toml"), encoding="utf-8", errors="replace") as fh:
+                    if "[tool.pytest" in fh.read(200_000):
+                        cmd = "python3 -m pytest"
+            except OSError:
+                pass
+        if not cmd and "Cargo.toml" in names:
+            cmd = "cargo test"
+        if not cmd and "go.mod" in names:
+            cmd = "go test ./..."
+        if cmd:
+            found.append((rel, cmd))
+        if depth < max_depth:
+            for n in sorted(names):
+                if n.startswith(".") or n in _TEST_SKIP_DIRS:
+                    continue
+                p = os.path.join(d, n)
+                if os.path.isdir(p) and not os.path.islink(p):
+                    queue.append((p, depth + 1))
+    return found
+
+
+def _test_commands_line(root: str) -> str:
+    cmds = _project_test_commands(root) if root else []
+    if not cmds:
+        return ""
+    return ("  TEST COMMANDS, from this project's own manifests — use these, never guess a runner "
+            "(a missing pytest fails silently behind a pipe): "
+            + "; ".join(f"{d} → {c}" for d, c in cmds) + "\n")
+
+
+# bash's words for a line whose quotes do not pair up.
+_SHELL_QUOTE_ERR_RE = re.compile(
+    r"unexpected EOF while looking for matching|syntax error near unexpected token|"
+    r"syntax error: unexpected end of file|unterminated quoted string")
+
 _RUN_DOC_ARGV = ("No other shell syntax (no pipes/redirects/;). sudo/su are blocked.")
 _RUN_DOC_SHELL = ("It runs in bash, so pipes, redirects, ;, ||, $( ), globs and heredocs work too "
                   "(e.g. 'npm test 2>&1 | tail -40'). sudo/su are blocked.")
@@ -8941,6 +9100,70 @@ def _shell_find(shells: list, key: str):
     return None
 
 
+_EPHEMERAL_FLOOR = None
+
+
+def _ws_ephemeral_floor() -> int:
+    """First port of the OS's ephemeral range — where a bind to port 0 lands. Linux reads
+    ip_local_port_range (32768 by default), macOS its sysctl (49152); Windows and anything
+    unreadable use the IANA 49152."""
+    global _EPHEMERAL_FLOOR
+    if _EPHEMERAL_FLOOR is None:
+        floor = 49152
+        try:
+            if sys.platform.startswith("linux"):
+                with open("/proc/sys/net/ipv4/ip_local_port_range", encoding="utf-8") as fh:
+                    floor = int(fh.read().split()[0])
+            elif sys.platform == "darwin":
+                import subprocess
+                out = subprocess.run(["sysctl", "-n", "net.inet.ip.portrange.first"],
+                                     capture_output=True, text=True, timeout=3).stdout.strip()
+                floor = int(out) if out.isdigit() else floor
+        except Exception:  # noqa: BLE001
+            pass
+        _EPHEMERAL_FLOOR = max(1024, floor)
+    return _EPHEMERAL_FLOOR
+
+
+def _ws_is_ephemeral_port(port) -> bool:
+    try:
+        return int(port) >= _ws_ephemeral_floor()
+    except (TypeError, ValueError):
+        return False
+
+
+def _server_as_shell(srv: dict) -> dict:
+    """A left-running server/app in the shape shell_output reads, so a command that was filed as
+    a server (wrongly, or not) can still be waited on and read (#360)."""
+    import time as _t
+    started = srv.get("started")
+    if started is None:
+        try:
+            started = _t.mktime(_t.strptime(str(srv.get("started_at")), "%Y-%m-%d %H:%M:%S"))
+        except (ValueError, OverflowError):
+            started = _t.time()
+    return {"id": str(srv.get("pid")), "pid": srv.get("pid"), "pgid": srv.get("pgid") or srv.get("pid"),
+            "command": srv.get("command"), "workdir": srv.get("workdir"), "log": srv.get("log"),
+            "exit_file": "", "started": started, "read_offset": srv.get("read_offset", 0),
+            "server": True}
+
+
+def _shell_or_server(shells: list, servers: list, key: str):
+    """shell_output's target: a shell by id, else a server by pid or port; with no key, the newest
+    of both — the model asking about "the" background job means the one it just started."""
+    key = (key or "").strip().lstrip("#")
+    if key:
+        sh = _shell_find(shells, key)
+        if sh is not None:
+            return sh
+        for srv in reversed(servers):
+            if key == str(srv.get("pid")) or any(key == str(p) for p in srv.get("ports") or []):
+                return _server_as_shell(srv)
+        return None
+    cands = list(shells) + [_server_as_shell(x) for x in servers]
+    return max(cands, key=lambda x: float(x.get("started") or 0)) if cands else None
+
+
 def _shell_kill(s: dict) -> None:
     """Stop a shell's whole process group and mark it killed (unless it already finished)."""
     import time as _t
@@ -9020,8 +9243,19 @@ def _range_is_covered(served, start: int, end: int):
     return None
 
 
-def _ws_distill_output(out: str, cap_head: int = 1200, cap_tail: int = 4000) -> str:
-    """Cap huge build/test output: failures live at the tail, context at the head."""
+_DISTILL_FLOOR = 5200  # 1200 head + 4000 tail — what every window got before #360
+
+
+def _ws_distill_output(out: str, cap_head: int = None, cap_tail: int = None) -> str:
+    """Cap huge build/test output: failures live at the tail, context at the head.
+
+    THE CAP SCALES WITH THE WINDOW, like a file read (#360 follow-up, issue #49). A fixed 5,200
+    chars cut a `git diff` in a commit turn and the model spent a step re-reading it with sed;
+    a command's output is a read too. Never below the old size, so a small window is unchanged."""
+    if cap_head is None or cap_tail is None:
+        total = max(_DISTILL_FLOOR, int(_OBS_CAPS.get("read") or 0))
+        cap_head = cap_head if cap_head is not None else int(total * 0.23)
+        cap_tail = cap_tail if cap_tail is not None else total - cap_head
     if len(out) <= cap_head + cap_tail + 200:
         return out
     return (out[:cap_head] + f"\n…[{len(out) - cap_head - cap_tail} chars omitted]…\n"
@@ -10289,9 +10523,16 @@ def run_agent_chat(cfg):
             _ws_servers_line += _shells_context_line(_shells_load())
         except Exception as _e:  # noqa: BLE001
             _log(f"shell context skip: {_e}")
+    _ws_tests_line = ""
+    if _WS_AVAILABLE and _WS_ACTIVE:
+        try:
+            _ws_tests_line = _test_commands_line(_WS_ACTIVE)
+        except Exception as _e:  # noqa: BLE001
+            _log(f"test command scan skip: {_e}")
     _ws_context_block = (
         _ws_current_line
         + f"  Other registered workspaces (use only if the user names them): {_ws_names}\n"
+        + _ws_tests_line
         + _ws_servers_line
         + f"  Current folder contents:\n"
         + "\n".join(f"    {line}" for line in _ws_overview.splitlines()) + "\n"
@@ -14356,7 +14597,8 @@ def run_agent_chat(cfg):
                 _scan = _shell_scan(command) if _shell_bin else None
                 if _scan and _scan["error"]:
                     msg = (f"Error: that command did NOT run — {_scan['error']}. Nothing was "
-                           "executed; fix the quoting and send it again.")
+                           "executed; fix the quoting and send it again."
+                           + (_HEREDOC_HINT if "quote" in str(_scan["error"]) else ""))
                     _last_obs["text"] = msg
                     return msg
                 _use_shell = bool(_scan) and _shell_needed(_scan)
@@ -14620,6 +14862,17 @@ def run_agent_chat(cfg):
                         # denied" is the part the reader already has; who we were and what we
                         # were allowed to be is the part they need, and without it both the
                         # model and the user are guessing at the next step.
+                        # A QUOTING ERROR NAMES THE FORM THAT WORKS (#360 follow-up). The model's
+                        # `git commit -m '…turn'\''s…'` lost its backslash to Python and bash
+                        # stopped on the quote; the next step was spent guessing. A heredoc in a
+                        # triple-quoted string has no quoting to get wrong.
+                        _hidden = _pipe_hidden_failure(_scan, out) if (rc == 0 and _use_shell) else ""
+                        if _hidden:
+                            result += _pipe_hidden_failure_note(_hidden)
+                            _emit({"type": "step", "text":
+                                   f"Command failed behind a pipe → {_trim_words(_hidden)}"})
+                        if rc != 0 and _use_shell and _SHELL_QUOTE_ERR_RE.search(out or ""):
+                            result += _HEREDOC_HINT
                         if rc != 0 and _WS_PERM_ERR_RE.search(out or ""):
                             _f = _ws_access_facts()
                             result = f"{result}\n\n{_ws_access_report(_f, _ws_paths_in(command))}"
@@ -14629,10 +14882,16 @@ def run_agent_chat(cfg):
                         return result
                     if _t.time() - start >= 3:
                         ports = _ws_listening_ports(proc.pid)
+                        # A port the OS PICKED (bind to 0) is a test run's own helper — the UI
+                        # suite's fake API on :52192 was filed as a "server", so the model could
+                        # not wait for the run and spent 3 steps polling it by hand (#360). Keep
+                        # waiting for it like any command; it hands off at the deadline if needed.
+                        if ports and all(_ws_is_ephemeral_port(p_) for p_ in ports):
+                            ports = []
                         if ports:
                             servers = _ws_load_servers()
                             servers.append({
-                                "pgid": proc.pid, "pid": proc.pid, "command": command,
+                                "pgid": proc.pid, "pid": proc.pid, "command": command, "started": start,
                                 "workdir": wd, "ports": ports, "log": log_path,
                                 "started_at": _t.strftime("%Y-%m-%d %H:%M:%S"),
                             })
@@ -14642,7 +14901,9 @@ def run_agent_chat(cfg):
                             tail = _ws_distill_output(_read_log())
                             result = (f"RUNNING: '{command}' is up and listening — {urls} "
                                       f"(pid {proc.pid}, log {log_path}). It stays running in "
-                                      "the background; use stop_server to stop it. "
+                                      "the background; use stop_server to stop it. If it is "
+                                      "NOT meant to stay up (a test run that opened a port), "
+                                      f"shell_output('{proc.pid}', wait_seconds=…) waits for it. "
                                       f"Startup output:\n{tail}")
                             _last_obs["text"] = result
                             return result
@@ -14654,7 +14915,7 @@ def run_agent_chat(cfg):
                         if _ws_gui_pids(proc.pid):
                             servers = _ws_load_servers()
                             servers.append({
-                                "pgid": proc.pid, "pid": proc.pid, "command": command,
+                                "pgid": proc.pid, "pid": proc.pid, "command": command, "started": start,
                                 "workdir": wd, "ports": [], "kind": "gui", "log": log_path,
                                 "started_at": _t.strftime("%Y-%m-%d %H:%M:%S"),
                             })
@@ -14785,11 +15046,13 @@ def run_agent_chat(cfg):
             try:
                 import time as _t
                 shells = _shells_load()
-                sh = _shell_find(shells, shell_id)
+                servers = _ws_load_servers()
+                sh = _shell_or_server(shells, servers, shell_id)
                 if sh is None:
-                    msg = ("No background shell matches '" + (shell_id or "") + "'. "
-                           + ("Shells: " + ", ".join(str(x.get("id")) for x in shells) if shells
-                              else "No background shells were started."))
+                    ids = [str(x.get("id")) for x in shells] + [str(x.get("pid")) for x in servers]
+                    msg = ("No background shell or server matches '" + (shell_id or "") + "'. "
+                           + ("Running: " + ", ".join(ids) if ids
+                              else "Nothing was left running in the background."))
                     _last_obs["text"] = msg
                     return msg
                 deadline = _t.time() + max(0, min(int(wait_seconds or 0), 540))
@@ -14804,14 +15067,22 @@ def run_agent_chat(cfg):
                 except OSError:
                     chunk = b""
                 # Re-read the file before writing: the terminal may have killed it meanwhile.
-                shells = _shells_load()
-                cur = _shell_find(shells, str(sh.get("id"))) or sh
-                cur["read_offset"] = int(sh.get("read_offset") or 0) + len(chunk)
-                if st["state"] != "running":
-                    cur["seen"] = True
-                _shells_save(shells)
+                if sh.get("server"):
+                    servers = _ws_load_servers(prune=False)
+                    for x in servers:
+                        if str(x.get("pid")) == str(sh.get("id")):
+                            x["read_offset"] = int(sh.get("read_offset") or 0) + len(chunk)
+                    _ws_save_servers(servers)
+                else:
+                    shells = _shells_load()
+                    cur = _shell_find(shells, str(sh.get("id"))) or sh
+                    cur["read_offset"] = int(sh.get("read_offset") or 0) + len(chunk)
+                    if st["state"] != "running":
+                        cur["seen"] = True
+                    _shells_save(shells)
                 new = _ws_distill_output(chunk.decode("utf-8", errors="replace"))
-                head = (f"shell {sh.get('id')}: {_shell_status_text(st).upper()} after "
+                head = (f"{'server' if sh.get('server') else 'shell'} {sh.get('id')}: "
+                        f"{_shell_status_text(st).upper()} after "
                         f"{_fmt_runtime(st['runtime'])} — '{_clip(str(sh.get('command')), 200)}' "
                         f"(log {sh.get('log')})")
                 if st["state"] == "exited":

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@tiens.nguyen/gu-cli",
-  "version": "1.0.829",
+  "version": "1.0.831",
   "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",