drydock-cli 3.0.52__tar.gz → 3.0.54__tar.gz

{drydock_cli-3.0.52/drydock_cli.egg-info → drydock_cli-3.0.54}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.52
+Version: 3.0.54
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.52 → drydock_cli-3.0.54}/drydock/tools/__init__.py

@@ -161,6 +161,34 @@ SCHEMAS = [
             "required": ["prompt"],
         },
     },
+    {
+        "name": "Dispatch",
+        "description": (
+            "Run SEVERAL read-only investigation sub-agents at once (in "
+            "parallel), each in its own fresh context with Read/Glob/Grep/Bash. "
+            "Use it to answer multiple INDEPENDENT questions concurrently, e.g. "
+            "'where is auth handled?', 'how does the DB layer work?', 'what tests "
+            "exist?'. Returns each agent's summary. They cannot write or recurse."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "tasks": {
+                    "type": "array",
+                    "description": "Up to 6 independent investigation tasks.",
+                    "items": {
+                        "type": "object",
+                        "properties": {
+                            "prompt": {"type": "string", "description": "The self-contained task."},
+                            "label": {"type": "string", "description": "Optional short label."},
+                        },
+                        "required": ["prompt"],
+                    },
+                },
+            },
+            "required": ["tasks"],
+        },
+    },
     {
         "name": "GitStatus",
         "description": (
@@ -787,15 +815,10 @@ _SUBAGENT_SYSTEM = (
 )
 
 
-def tool_task(params: dict, config: dict) -> str:
-    """Spawn a read-only sub-agent with a FRESH context for a focused
-    exploration task, returning only its final summary. Keeps big searches out
-    of the main agent's context. Cannot recurse (no `task` tool) and cannot
-    write (no Write/Edit), so it can never corrupt the parent's work."""
-    prompt = (params.get("prompt") or params.get("description") or "").strip()
-    if not prompt:
-        return "Error: `task` needs a `prompt` describing what to investigate."
-    # Lazy import to avoid a tools <-> agent import cycle.
+def _run_subagent(prompt: str, config: dict) -> str:
+    """Run one read-only sub-agent to completion and return its final summary.
+    Shared by `task` (one) and `Dispatch` (many in parallel). Hard-capped; never
+    raises (a sub-agent must not crash the parent turn)."""
     from drydock.agent import run as agent_run, AgentState, TurnDone
 
     sub_state = AgentState()
@@ -806,6 +829,9 @@ def tool_task(params: dict, config: dict) -> str:
     sub_config["max_tool_calls"] = 20
     sub_config.pop("_todo", None)      # the sub-agent keeps no checklist of its own
     sub_config.pop("_plan_autocontinue", None)
+    # Own abort holder so parallel sub-agents don't clobber each other's (or the
+    # parent's) in-flight client/proc handles in the shared dict.
+    sub_config["_abort"] = {}
     steps = 0
     try:
         for ev in agent_run(prompt, sub_state, sub_config, _SUBAGENT_SYSTEM):
@@ -819,6 +845,54 @@ def tool_task(params: dict, config: dict) -> str:
     return f"[sub-agent finished {steps} step(s) with no summary]"
 
 
+def tool_task(params: dict, config: dict) -> str:
+    """Spawn a read-only sub-agent with a FRESH context for a focused
+    exploration task, returning only its final summary. Keeps big searches out
+    of the main agent's context. Cannot recurse (no `task` tool) and cannot
+    write (no Write/Edit), so it can never corrupt the parent's work."""
+    prompt = (params.get("prompt") or params.get("description") or "").strip()
+    if not prompt:
+        return "Error: `task` needs a `prompt` describing what to investigate."
+    return _run_subagent(prompt, config)
+
+
+def tool_dispatch(params: dict, config: dict) -> str:
+    """Run SEVERAL read-only sub-agents concurrently and return all summaries.
+    Each gets its own fresh context + Read/Glob/Grep/Bash (no recursion, no
+    writes). Use it to investigate independent questions at once."""
+    import concurrent.futures
+
+    raw = params.get("tasks") or params.get("agents") or []
+    if isinstance(raw, dict):
+        raw = [raw]
+    norm: list[dict] = []
+    for t in raw:
+        if isinstance(t, str) and t.strip():
+            norm.append({"prompt": t.strip(), "label": ""})
+        elif isinstance(t, dict):
+            p = (t.get("prompt") or t.get("description") or "").strip()
+            if p:
+                norm.append({"prompt": p, "label": (t.get("label") or t.get("description") or "").strip()})
+    if not norm:
+        return "Error: `Dispatch` needs a `tasks` list, each item a prompt (string) or {prompt, label}."
+    norm = norm[:6]  # cap fan-out
+
+    results: list[str] = [""] * len(norm)
+    with concurrent.futures.ThreadPoolExecutor(max_workers=min(4, len(norm))) as ex:
+        futs = {ex.submit(_run_subagent, t["prompt"], config): i for i, t in enumerate(norm)}
+        for fut in concurrent.futures.as_completed(futs):
+            i = futs[fut]
+            try:
+                results[i] = fut.result()
+            except Exception as e:  # noqa: BLE001
+                results[i] = f"[agent error: {e}]"
+    parts = [f"Dispatched {len(norm)} sub-agent(s) in parallel:"]
+    for i, t in enumerate(norm):
+        label = t["label"] or f"agent {i + 1}"
+        parts.append(f"\n=== {label} ===\n{results[i]}")
+    return "\n".join(parts)
+
+
 def _git_cwd(config: dict) -> str:
     return config.get("cwd") or os.getcwd()
 
@@ -940,6 +1014,7 @@ _TOOLS = [
     ("Grep", tool_grep, True),
     ("todo", tool_todo, False),
     ("task", tool_task, True),
+    ("Dispatch", tool_dispatch, True),
     ("Knowledge", tool_knowledge, True),
     ("WebSearch", tool_websearch, True),
     ("WebFetch", tool_webfetch, True),
@@ -955,7 +1030,8 @@ def register_all():
         func = {
             "Read": tool_read, "Write": tool_write, "Edit": tool_edit,
             "Bash": tool_bash, "Glob": tool_glob, "Grep": tool_grep,
-            "todo": tool_todo, "task": tool_task, "Knowledge": tool_knowledge,
+            "todo": tool_todo, "task": tool_task, "Dispatch": tool_dispatch,
+            "Knowledge": tool_knowledge,
             "WebSearch": tool_websearch, "WebFetch": tool_webfetch,
             "GitStatus": tool_gitstatus, "GitDiff": tool_gitdiff,
             "GitLog": tool_gitlog, "GitCommit": tool_gitcommit,
@@ -963,8 +1039,8 @@ def register_all():
         # Read-only w.r.t. the parent's files (GitStatus/Diff/Log inspect only;
         # GitCommit writes a local, reversible commit).
         read_only = name in (
-            "Read", "Glob", "Grep", "task", "Knowledge", "WebSearch", "WebFetch",
-            "GitStatus", "GitDiff", "GitLog",
+            "Read", "Glob", "Grep", "task", "Dispatch", "Knowledge",
+            "WebSearch", "WebFetch", "GitStatus", "GitDiff", "GitLog",
         )
         register(ToolDef(name=name, schema=schema, func=func, read_only=read_only))
 

{drydock_cli-3.0.52 → drydock_cli-3.0.54}/drydock/tui/app.py

@@ -153,7 +153,10 @@ class DrydockApp(App):
         self._abort_inflight()
         dropped = len(self._queue)
         self._queue.clear()
+        looping = self._repeat is not None
+        self._repeat = None  # Esc/stop also ends an active /loop
         note = "⏹ stopped." + (f" (discarded {dropped} queued)" if dropped else "")
+        note += " loop ended." if looping else ""
         self._info(note)
         self._refresh_status()
 
@@ -251,6 +254,7 @@ class DrydockApp(App):
         # A plain dict survives run()'s dict(config) shallow copy by reference.
         self.config["_abort"] = {}
         self._queue: list[str] = []  # prompts submitted while a turn is running
+        self._repeat: dict | None = None  # active /loop: {prompt, remaining, total}
         self._ctx_tokens = 0  # current context size (last turn's prompt tokens)
         self._ctrl_c_armed = False  # first Ctrl+C arms; second within ~2s exits
         # Live "working" line state.
@@ -489,10 +493,13 @@ class DrydockApp(App):
                 "  /graphrag        build/query a knowledge base from your docs\n"
                 "                   /graphrag build <path> · /graphrag status · /graphrag clear\n"
                 "  /skills          list your reusable /<name> skills\n"
+                "  /loop            /loop <count> <prompt> — repeat a prompt (Esc stops)\n"
                 "  /clear           reset the conversation\n"
                 "  /quit            exit\n"
                 "Type a task and press Enter. ↑/↓ recall history · Esc stops · Ctrl+O expands tools."
             )
+        elif cmd == "/loop":
+            self._cmd_loop(arg)
         elif cmd == "/skills":
             self._cmd_skills()
         elif cmd[1:] in self._skills:
@@ -500,6 +507,29 @@ class DrydockApp(App):
         else:
             self._mount(ErrorMessage(f"unknown command: {cmd} (try /help)"))
 
+    def _cmd_loop(self, arg: str) -> None:
+        """/loop <count> <prompt> — run <prompt> up to <count> times (1–50),
+        re-submitting after each turn finishes. Esc (or /stop) ends the loop."""
+        parts = arg.split(maxsplit=1)
+        if len(parts) < 2 or not parts[0].isdigit():
+            self._info(
+                "usage: /loop <count> <prompt>   e.g.  /loop 5 fix the next "
+                "failing test and run pytest\n(count 1–50; Esc stops the loop)"
+            )
+            return
+        count = max(1, min(int(parts[0]), 50))
+        prompt = parts[1].strip()
+        if not prompt:
+            self._info("usage: /loop <count> <prompt>")
+            return
+        if self._busy:
+            self._info("A turn is already running — stop it (Esc) before starting a loop.")
+            return
+        self._repeat = {"prompt": prompt, "remaining": count, "total": count}
+        self._info(f"↻ looping {count}× (Esc to stop):  {prompt}")
+        self._mount(UserMessage(prompt))
+        self._begin(prompt)
+
     def _cmd_skills(self) -> None:
         if not self._skills:
             self._info(
@@ -780,6 +810,15 @@ class DrydockApp(App):
         if self._queue:
             self._begin(self._queue.pop(0))
             return
+        # /loop: re-run the prompt until the iteration count is exhausted (Esc/
+        # stop clears self._repeat). Queued user prompts take priority (above).
+        if self._repeat and self._repeat["remaining"] > 1 and not self._cancel.is_set():
+            self._repeat["remaining"] -= 1
+            done = self._repeat["total"] - self._repeat["remaining"] + 1
+            self._info(f"↻ loop iteration {done}/{self._repeat['total']}")
+            self._begin(self._repeat["prompt"])
+            return
+        self._repeat = None
         self._refresh_status()
         self.query_one("#prompt", PromptArea).focus()
 

{drydock_cli-3.0.52 → drydock_cli-3.0.54}/drydock/tui/widgets.py

@@ -153,7 +153,7 @@ class PromptHistory:
 # completes the prefix.
 SLASH_COMMANDS = [
     "/help", "/model", "/cwd", "/undo", "/back", "/stop", "/status",
-    "/compact", "/graphrag", "/clear", "/quit",
+    "/compact", "/graphrag", "/skills", "/loop", "/clear", "/quit",
 ]
 
 

{drydock_cli-3.0.52 → drydock_cli-3.0.54/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.52
+Version: 3.0.54
 Summary: Drydock — a local, provider-agnostic terminal coding agent for local LLMs
 Author: Frank Bobe III
 License-Expression: Apache-2.0

{drydock_cli-3.0.52 → drydock_cli-3.0.54}/drydock_cli.egg-info/SOURCES.txt

@@ -43,6 +43,7 @@ tests/test_config.py
 tests/test_config_migration.py
 tests/test_context_limit_config.py
 tests/test_detect.py
+tests/test_dispatch.py
 tests/test_empty_response.py
 tests/test_failure_loop.py
 tests/test_first_run_setup.py

{drydock_cli-3.0.52 → drydock_cli-3.0.54}/pyproject.toml

@@ -7,7 +7,7 @@ build-backend = "setuptools.build_meta"
 # PyPI distribution name is drydock-cli (the established install name, continued
 # from the retired v2 fork); the import package + CLI command stay `drydock`.
 name = "drydock-cli"
-version = "3.0.52"
+version = "3.0.54"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

drydock_cli-3.0.54/tests/test_dispatch.py

@@ -0,0 +1,62 @@
+"""Multi-agent: the Dispatch tool fans out several read-only sub-agents in
+parallel and returns all summaries. The sub-agent runner is mocked so tests are
+deterministic and don't need the LLM."""
+from __future__ import annotations
+
+import time
+
+import drydock.tools as T
+
+
+def test_dispatch_runs_each_task_and_labels(monkeypatch):
+    monkeypatch.setattr(T, "_run_subagent", lambda p, c: f"R:{p}")
+    out = T.tool_dispatch({"tasks": [
+        {"prompt": "find auth", "label": "auth"},
+        {"prompt": "find db"},
+    ]}, {})
+    assert "=== auth ===" in out and "R:find auth" in out
+    assert "=== agent 2 ===" in out and "R:find db" in out
+
+
+def test_dispatch_accepts_string_tasks(monkeypatch):
+    monkeypatch.setattr(T, "_run_subagent", lambda p, c: f"R:{p}")
+    out = T.tool_dispatch({"tasks": ["a", "b", "c"]}, {})
+    assert out.count("R:") == 3
+
+
+def test_dispatch_needs_tasks():
+    assert "needs a `tasks`" in T.tool_dispatch({"tasks": []}, {})
+    assert "needs a `tasks`" in T.tool_dispatch({}, {})
+
+
+def test_dispatch_caps_fanout(monkeypatch):
+    monkeypatch.setattr(T, "_run_subagent", lambda p, c: "x")
+    out = T.tool_dispatch({"tasks": [f"t{i}" for i in range(20)]}, {})
+    assert "Dispatched 6 sub-agent" in out  # capped at 6
+
+
+def test_dispatch_isolates_subagent_errors(monkeypatch):
+    def runner(p, c):
+        if "boom" in p:
+            raise RuntimeError("kaboom")
+        return f"R:{p}"
+    monkeypatch.setattr(T, "_run_subagent", runner)
+    out = T.tool_dispatch({"tasks": ["ok", "boom"]}, {})
+    assert "R:ok" in out and "agent error" in out  # one fails, the other survives
+
+
+def test_dispatch_runs_concurrently(monkeypatch):
+    # 4 tasks that each sleep 0.2s should finish in well under 0.8s (serial time)
+    def slow(p, c):
+        time.sleep(0.2)
+        return "done"
+    monkeypatch.setattr(T, "_run_subagent", slow)
+    t0 = time.monotonic()
+    T.tool_dispatch({"tasks": ["a", "b", "c", "d"]}, {})
+    assert time.monotonic() - t0 < 0.6  # parallel, not 0.8s serial
+
+
+def test_task_still_works_via_shared_runner(monkeypatch):
+    monkeypatch.setattr(T, "_run_subagent", lambda p, c: f"summary:{p}")
+    assert T.tool_task({"prompt": "explore X"}, {}) == "summary:explore X"
+    assert "needs a `prompt`" in T.tool_task({}, {})

{drydock_cli-3.0.52 → drydock_cli-3.0.54}/tests/test_tui.py

@@ -348,3 +348,40 @@ def test_new_user_turn_clears_stale_plan():
             assert str(panel.render()) == ""            # panel cleared
 
     asyncio.run(main())
+
+
+def test_loop_command_iterates_and_stops():
+    """/loop <n> <prompt> re-runs the prompt n times, then clears; Esc ends it."""
+    async def main():
+        app = DrydockApp({"model": "gemma4", "provider": "vllm", "cwd": "/tmp"})
+        async with app.run_test() as pilot:
+            await pilot.pause()
+            begins = []
+            app._begin = lambda text: begins.append(text)  # stub out the real agent
+
+            # bad usage → no loop
+            app._handle_slash("/loop notanumber")
+            assert app._repeat is None and not begins
+
+            # /loop 3 <prompt> → starts, first iteration begun
+            app._handle_slash("/loop 3 do the thing")
+            assert app._repeat and app._repeat["total"] == 3
+            assert begins == ["do the thing"]
+
+            # each finished turn re-begins until the count is exhausted
+            from drydock.tui.messages import AgentFinished
+            app.on_agent_finished(AgentFinished())  # iter 2
+            app.on_agent_finished(AgentFinished())  # iter 3
+            assert len(begins) == 3
+            app.on_agent_finished(AgentFinished())  # done → loop cleared
+            assert app._repeat is None
+            assert len(begins) == 3  # no 4th run
+
+            # Esc/stop ends an active loop
+            app._begin = lambda text: begins.append(text)
+            app._handle_slash("/loop 5 again")
+            app._busy = True
+            app.action_stop()
+            assert app._repeat is None
+
+    asyncio.run(main())