drydock-cli 2.6.89__tar.gz → 2.6.91__tar.gz

drydock_cli-2.6.91/.auto_release.lock

@@ -0,0 +1 @@
+1493850

{drydock_cli-2.6.89 → drydock_cli-2.6.91}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.6.89
+Version: 2.6.91
 Summary: Local-first CLI coding agent — tested with Gemma 4 26B via vLLM
 Project-URL: Homepage, https://github.com/fbobe321/drydock
 Project-URL: Repository, https://github.com/fbobe321/drydock

{drydock_cli-2.6.89 → drydock_cli-2.6.91}/drydock/core/agent_loop.py

@@ -1445,26 +1445,42 @@ class AgentLoop:
         available_tools = self.format_handler.get_available_tools(self.tool_manager)
         tool_choice = self.format_handler.get_tool_choice()
 
-        # Loop-break via tool_choice="none" — when repetition is severe
-        # (FORCE_STOP signal), force the model to emit TEXT next turn.
-        # Cannot call a tool on this turn. Forces reflection/replan via
-        # natural language, then tool_choice returns to "auto" on the
-        # following turn. This breaks attractor loops where the model
-        # keeps firing identical tool calls despite advisories (144x
-        # write_file, 13x read_file observed in stress session
-        # 20260415_021415_ac6bd91f).
-        # Ratelimit: only force tool_choice=none once per N turns so we
-        # don't ping-pong between "none" and "auto" forever.
+        # Loop-break when FORCE_STOP detected. Two-tier:
+        #   1. If _hot_tool_path is set (specific tool+path dominates the
+        #      recent window), REMOVE that tool from available_tools for
+        #      this turn. Model must diversify — can still use other tools.
+        #      This is surgical: the model can read, bash, SR, etc., just
+        #      can't call the over-used tool on the over-used path.
+        #   2. Otherwise (generic FORCE_STOP), fall back to tool_choice=none
+        #      so model emits text. Last resort.
+        # The hot-path flag is consumed (cleared) here so it's a one-turn
+        # mute. If the model goes back to looping next turn, we'll re-detect
+        # and re-mute.
         if getattr(self, "_loop_detected", False) and getattr(self, "_loop_signal", "") == "FORCE_STOP":
-            last_forced = getattr(self, "_last_tool_choice_none_turn", -999)
-            current_turn = len(self.messages)
-            if current_turn - last_forced >= 4:
+            hot = getattr(self, "_hot_tool_path", None)
+            if hot and hot[0] and available_tools:
+                hot_tool_name, hot_path = hot
+                before = len(available_tools)
+                available_tools = [
+                    t for t in available_tools
+                    if getattr(t.function, "name", None) != hot_tool_name
+                ]
+                after = len(available_tools)
+                if before != after:
+                    logger.info(
+                        "[LOOP-BREAK] FORCE_STOP hot=(%s, %s) — "
+                        "removed '%s' from available_tools for 1 turn "
+                        "(%d → %d tools). Model must diversify.",
+                        hot_tool_name, hot_path[:50], hot_tool_name, before, after,
+                    )
+            else:
+                # No specific tool+path hot-combo — fall back to text-only.
                 tool_choice = "none"
-                self._last_tool_choice_none_turn = current_turn
                 logger.info(
-                    "[LOOP-BREAK] FORCE_STOP signal → tool_choice=none "
-                    "for this turn (forces text response, breaks attractor)"
+                    "[LOOP-BREAK] FORCE_STOP (no hot-combo) → tool_choice=none"
                 )
+            # Consume the flag — one-turn action.
+            self._hot_tool_path = None
         _t2 = time.perf_counter()
 
         n_msgs = len(self.messages)
@@ -1917,19 +1933,17 @@ class AgentLoop:
         # Check 1b: Path-dominance oscillation. The model is stuck on a
         # single file — writing, rewriting, SR-patching, reading — even
         # though each call's signature differs enough to dodge Check 1.
-        # If ≥9 of the last 12 tool calls touch the SAME path, trip
-        # FORCE_STOP regardless of signature variance.
+        # If ≥9 of the last 12 tool calls touch the SAME path, record
+        # the (tool, path) hot-combo for the NEXT turn to act on.
         #
         # Tolerance: normal feature-addition work spreads writes across
         # many prompts (+3 writes per prompt over 100+ tool calls in
         # the stress run), so 9-of-12 is a much tighter cluster than
-        # legitimate progress. Observed attractors dodged Check 1:
-        #   session 20260415_025053: write↔SR ping-pong on json_set_tool.py
-        #   session 20260415_041558: 8 sig variants on parser.py with
-        #     leaked path tokens (now cleaned at parse time)
-        #   session 20260415_055037: 6-7 sig variants on tools.py
+        # legitimate progress.
         if len(sigs) >= 12:
-            paths: list[str] = []
+            # Collect recent (tool_name, path) pairs for hot-combo detection
+            path_tool_pairs: list[tuple[str, str]] = []
+            paths_only: list[str] = []
             for msg in list(reversed(self.messages))[:40]:
                 if msg.role == Role.assistant and msg.tool_calls:
                     for tc in msg.tool_calls:
@@ -1941,16 +1955,28 @@ class AgentLoop:
                             continue
                         p = a.get("file_path") or a.get("path") or ""
                         if p:
-                            paths.append(p)
-                        if len(paths) >= 12:
+                            paths_only.append(p)
+                            path_tool_pairs.append((tc.function.name or "", p))
+                        if len(paths_only) >= 12:
                             break
-                    if len(paths) >= 12:
+                    if len(paths_only) >= 12:
                         break
-            last_12_paths = paths[:12]
+            last_12_paths = paths_only[:12]
+            last_12_pairs = path_tool_pairs[:12]
             if len(last_12_paths) >= 12:
-                most = max(set(last_12_paths), key=last_12_paths.count)
-                if last_12_paths.count(most) >= 9:
+                most_path = max(set(last_12_paths), key=last_12_paths.count)
+                if last_12_paths.count(most_path) >= 9:
+                    # Record the dominating (tool, path) pair with the
+                    # highest count so the agent can mute that specific
+                    # tool on that path next turn.
+                    from collections import Counter
+                    pair_counts = Counter(last_12_pairs)
+                    top_pair, top_count = pair_counts.most_common(1)[0]
+                    self._hot_tool_path = top_pair if top_count >= 5 else (None, most_path)
                     return "FORCE_STOP"
+        # Reset hot-path when no path-dominance detected
+        if not getattr(self, "_hot_tool_path", None) or True:
+            pass  # hot path set only when triggered; consumed in _chat
 
         if (
             len(sigs) >= REPEAT_WARNING_THRESHOLD

{drydock_cli-2.6.89 → drydock_cli-2.6.91}/drydock/core/llm/format.py

@@ -201,36 +201,42 @@ class APIToolFormatHandler:
         # Keeping them wastes context, confuses subsequent turns, and can
         # fake-signal "done" to harnesses that watch for text-only messages.
         content = message.content
-        if content and ("<|channel>" in content or "<|tool_call>" in content):
+        if content:
             import re as _re
-            # Strip <|channel>...<channel|> or <|channel>...<tool_call|> blocks
-            content = _re.sub(
-                r"<\|channel\>.*?(?:<channel\|>|<tool_call\|>)",
-                "",
-                content,
-                flags=_re.DOTALL,
-            )
-            # Strip bare <|tool_call>call:...<tool_call|> blocks (no channel
-            # prefix). Unterminated variants (stream cut off mid-emission)
-            # are stripped by the catch-all below.
-            content = _re.sub(
-                r"<\|tool_call\>.*?<tool_call\|>",
-                "",
-                content,
-                flags=_re.DOTALL,
-            )
-            # Final catch-all: any dangling <|...|> or <...|> tokens that
-            # didn't form a complete pair (stream truncation).
-            content = _re.sub(r"<\|[^>]{0,200}\|>", "", content)
-            content = _re.sub(r"<\|[^>]{0,200}>", "", content)
-            content = _re.sub(r"<[^>]{0,200}\|>", "", content)
-            # If remaining content is just tool-call-leak residue (starts
-            # with `call:toolname{` after stripping), nuke it. Otherwise
-            # harness watchers treat the garbage text as a completion
-            # signal. agent_loop's empty-content nudge will ask the model
-            # to continue with a real tool call.
+            # Case 1: marked leaks with <|...|> delimiters.
+            if "<|channel>" in content or "<|tool_call>" in content:
+                content = _re.sub(
+                    r"<\|channel\>.*?(?:<channel\|>|<tool_call\|>)",
+                    "", content, flags=_re.DOTALL,
+                )
+                content = _re.sub(
+                    r"<\|tool_call\>.*?<tool_call\|>",
+                    "", content, flags=_re.DOTALL,
+                )
+                content = _re.sub(r"<\|[^>]{0,200}\|>", "", content)
+                content = _re.sub(r"<\|[^>]{0,200}>", "", content)
+                content = _re.sub(r"<[^>]{0,200}\|>", "", content)
+
+            # Case 2: unmarked degenerate fake-tool-call text. Gemma 4
+            # sometimes stops emitting real tool_calls and instead writes
+            # the tool-call template as plain text, like:
+            #   "thought call:write_file{content:class Foo: ..."
+            #   "(thought) call:write_file{...}"
+            # Drydock parses no tool_calls → nothing runs → user-facing
+            # hang. Observed 2026-04-15 stress session 20260415_072556
+            # prompts 16-30: every assistant turn was pure fake-tool text.
+            # Strip leading "thought"/"(thought)" filler and match the
+            # `call:name{...}` shape so the agent loop sees empty content
+            # and can fire its recovery nudge.
             stripped = content.strip()
-            if _re.match(r"^(call:\w+\{|\w+\{content:)", stripped):
+            # Peel "thought" or "(thought)" prefix (case-insensitive, optional
+            # whitespace)
+            peeled = _re.sub(
+                r"^\s*\(?thought\)?\s*", "", stripped, flags=_re.IGNORECASE,
+            )
+            if _re.match(r"^call:\w+\s*\{", peeled) or _re.match(r"^\w+\s*\{\s*content\s*:", peeled):
+                content = None
+            elif _re.match(r"^(call:\w+\{|\w+\{content:)", stripped):
                 content = None
             else:
                 content = stripped or None

{drydock_cli-2.6.89 → drydock_cli-2.6.91}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.6.89"
+version = "2.6.91"
 description = "Local-first CLI coding agent — tested with Gemma 4 26B via vLLM"
 readme = "README.md"
 requires-python = ">=3.12"

drydock_cli-2.6.91/scripts/stress_prompts_50.txt

@@ -0,0 +1,55 @@
+# Bootstrap: build tool_agent from PRD first
+Review the PRD.md in this directory. Build the initial tool_agent package with the 6 built-in tools, pipe syntax parser, plugin loader, conversation memory, and CLI entrypoint. After all files are written, run `python3 -m tool_agent --list-tools` to verify it works.
+
+# New built-in tools (40)
+Add a hash tool that computes SHA-256 of a string. Usage: hash <text>. Update --list-tools.
+Add an md5 tool that computes MD5 of a string. Usage: md5 <text>.
+Add a base64 tool with encode and decode modes. Usage: base64 encode <text> | base64 decode <text>.
+Add a url_encode tool. Usage: url_encode <text>.
+Add a url_decode tool. Usage: url_decode <text>.
+Add a timestamp tool that returns current Unix timestamp.
+Add a random tool that picks a random integer between two bounds. Usage: random <min> <max>.
+Add a uuid tool that generates a random UUID v4.
+Add a reverse_words tool (not reverse chars) that reverses word order.
+Add a title_case tool that title-cases input.
+Add a upper tool for uppercase.
+Add a lower tool for lowercase.
+Add a length tool that returns character count.
+Add a line_count tool that counts newlines in a file.
+Add a char_count tool that counts characters excluding whitespace.
+Add a env_get tool that returns an environment variable value. Usage: env_get <name>.
+Add a env_list tool that prints all env vars.
+Add a path_join tool that joins path components.
+Add a path_basename tool that returns the basename of a path.
+Add a path_dirname tool that returns the dirname of a path.
+Add a json_get tool that extracts a field by dotted path. Usage: json_get <json> <path>.
+Add a json_set tool that sets a field by dotted path. Usage: json_set <json> <path> <value>.
+Add a json_keys tool that lists top-level keys.
+Add a yaml_to_json tool that converts YAML to JSON.
+Add a json_to_yaml tool that converts JSON to YAML.
+Add a xml_parse tool that converts XML to JSON dict.
+Add a count_lines tool for number of lines in string input.
+Add a head tool that returns first N lines. Usage: head <n> <text>.
+Add a tail tool that returns last N lines. Usage: tail <n> <text>.
+Add a sort_lines tool. Usage: sort_lines <text>.
+Add a uniq tool that removes consecutive duplicate lines.
+Add a replace tool with three args: old, new, text. Usage: replace <old> <new> <text>.
+Add a regex_match tool. Usage: regex_match <pattern> <text>, returns first match.
+Add a regex_replace tool. Usage: regex_replace <pattern> <replacement> <text>.
+Add a regex_findall tool. Usage: regex_findall <pattern> <text>.
+Add a echo_tool that simply echoes input.
+Add a sleep tool that pauses for N seconds (useful for testing).
+Add a noop tool that does nothing.
+Add a ping_check tool that checks if a host resolves (no actual ping, use socket).
+Add a disk_usage tool that returns free/used/total bytes of cwd.
+
+# Plugin / extension features (20)
+Support hot-reload of plugins without restarting the CLI.
+Add a --plugin-path CLI flag that accepts a directory of plugins.
+Allow plugins to declare dependencies on other tools, resolved at load time.
+Plugin manifest format: a plugin may include a manifest.json with metadata (name, version, author).
+Ignore plugins whose manifest.json declares enabled: false.
+Auto-generate --list-plugins that lists every loaded plugin with version.
+Allow plugins to register multiple tools via a register_tools() function.
+Support per-plugin configuration files at plugins/<name>.conf.
+Add plugin load timing logged in --verbose mode.

drydock_cli-2.6.89/.auto_release.lock

@@ -1 +0,0 @@
-1479307