drydock-cli 3.0.129__tar.gz → 3.0.132__tar.gz

{drydock_cli-3.0.129/drydock_cli.egg-info → drydock_cli-3.0.132}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.129
+Version: 3.0.132
 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.129 → drydock_cli-3.0.132}/drydock/agent.py

@@ -34,7 +34,7 @@ def _plan_has_unfinished(config: dict) -> bool:
     return bool(todo) and any(status != "done" for _, status in todo)
 
 from drydock.providers import stream, AssistantTurn, ReasoningChunk, TextChunk, StallRetry, RepetitionDetected
-from drydock.tool_registry import schemas, execute
+from drydock.tool_registry import schemas, execute_structured
 from drydock.tools import register_all
 
 # Register the built-in tools as a side effect of importing the agent. This is
@@ -49,7 +49,7 @@ from drydock.compaction import (
 from drydock.loop_detect import LoopTracker
 from drydock.task_state import TaskState
 from drydock.verification import looks_like_verification, parse_evidence
-from drydock.events import emit as _emit
+from drydock.events import EventLog, emit as _emit
 from drydock.tuning import (
     filter_tool_schemas,
     hallucinated_tool_message,
@@ -84,7 +84,7 @@ class AgentState:
     turn_count: int = 0
     current_effort: str = ""  # "high"/"low" of the in-flight LLM call (for the UI)
     task: "TaskState" = field(default_factory=lambda: TaskState())  # structured objective
-    events: object | None = None  # optional EventLog for a durable execution trace
+    events: "EventLog | None" = None  # optional durable execution trace
 
 
 def drop_last_turn(messages: list) -> bool:
@@ -422,14 +422,17 @@ def run(
             halluc = hallucinated_tool_message(tc["name"])
             if halluc is not None:
                 result = halluc
+                tool_result = None
             elif allow is not None and tc["name"] not in allow:
                 result = (
                     f"[The '{tc['name']}' tool is not available here. You may use "
                     f"only: {', '.join(allow)}. Use one of those, or reply with "
                     "your final summary.]"
                 )
+                tool_result = None
             else:
-                result = execute(tc["name"], tc["input"], config)
+                tool_result = execute_structured(tc["name"], tc["input"], config)
+                result = tool_result.text
             # Track consecutive byte-identical calls — same name, args AND raw
             # result (captured before annotate prepends its note, which changes
             # each call) — for the safety valve below. A differing result
@@ -452,10 +455,21 @@ def run(
                     _emit(state, "verification", status=last_verification.status,
                           exit_code=last_verification.exit_code)
 
-            _emit(state, "tool", name=tc["name"],
-                  input=str(tc.get("input"))[:200],
-                  result_chars=len(str(result)),
-                  error=str(result)[:80].lower().startswith("error"))
+            # Sync the rolling plan when the model updates its checklist, keeping
+            # stable step ids + capping pending steps; record each revision.
+            if tc["name"] == "todo" and isinstance(config.get("_todo"), list):
+                if state.task.plan.update_from_items(config["_todo"]):
+                    _emit(state, "plan", version=state.task.plan.version,
+                          steps=[(s["id"], s["status"]) for s in state.task.plan.steps])
+
+            if tool_result is not None:
+                _emit(state, "tool", input=str(tc.get("input"))[:200],
+                      **tool_result.to_event())
+            else:
+                _emit(state, "tool", name=tc["name"],
+                      input=str(tc.get("input"))[:200],
+                      result_chars=len(str(result)),
+                      status="ok")
             yield ToolEnd(tc["name"], result)
 
             # Append tool result

{drydock_cli-3.0.129 → drydock_cli-3.0.132}/drydock/task_state.py

@@ -40,12 +40,64 @@ def extract_acceptance_criteria(objective: str, limit: int = 10) -> list[str]:
     return out[:limit]
 
 
+def _step_id(text: str) -> str:
+    """Stable short id for a plan step, derived from its text (so the SAME step
+    keeps its id across plan revisions). Deterministic — no randomness/time."""
+    h = 0
+    for ch in text.strip().lower():
+        h = (h * 131 + ord(ch)) & 0xFFFFFFFF
+    return f"s{h:08x}"
+
+
+@dataclass
+class RollingPlan:
+    """A short, updateable plan (PRD Epic C): one ACTIVE step + a few pending ones,
+    each with a stable id. Rebuilt from the checklist the model maintains; ids are
+    text-derived so an unchanged step keeps its id across revisions."""
+    steps: list[dict] = field(default_factory=list)  # {id, text, status}
+    version: int = 0
+    max_pending: int = 4
+
+    def update_from_items(self, items: list[tuple[str, str]]) -> bool:
+        """Sync from (text, status) checklist pairs. Caps pending steps (keeps the
+        active + first max_pending pending). Returns True if the plan CHANGED."""
+        steps = [{"id": _step_id(t), "text": t, "status": s} for t, s in items if t]
+        # active = first in_progress, else first pending
+        active = next((s for s in steps if s["status"] == "in_progress"), None)
+        if active is None:
+            active = next((s for s in steps if s["status"] == "pending"), None)
+        kept, pending_kept = [], 0
+        for s in steps:
+            if s["status"] == "done" or s is active:
+                kept.append(s)
+            elif s["status"] == "pending" and pending_kept < self.max_pending:
+                kept.append(s); pending_kept += 1
+            elif s["status"] == "in_progress":
+                kept.append(s)
+        changed = [(s["id"], s["status"]) for s in kept] != [(s["id"], s["status"]) for s in self.steps]
+        if changed:
+            self.steps = kept
+            self.version += 1
+        return changed
+
+    def active_step(self) -> dict | None:
+        return next((s for s in self.steps if s["status"] == "in_progress"), None) \
+            or next((s for s in self.steps if s["status"] == "pending"), None)
+
+    def remaining(self) -> int:
+        return sum(1 for s in self.steps if s["status"] != "done")
+
+    def to_dict(self) -> dict:
+        return {"steps": list(self.steps), "version": self.version}
+
+
 @dataclass
 class TaskState:
     """Authoritative task facts, independent of the message transcript."""
     objective: str = ""
     acceptance_criteria: list[str] = field(default_factory=list)
     phase: str = "understand"
+    plan: RollingPlan = field(default_factory=RollingPlan)
 
     @classmethod
     def from_objective(cls, objective: str) -> TaskState:
@@ -61,14 +113,20 @@ class TaskState:
             "objective": self.objective,
             "acceptance_criteria": list(self.acceptance_criteria),
             "phase": self.phase,
+            "plan": self.plan.to_dict(),
         }
 
     @classmethod
     def from_dict(cls, d: dict) -> TaskState:
+        plan = RollingPlan()
+        pd = d.get("plan") or {}
+        plan.steps = list(pd.get("steps", []))
+        plan.version = pd.get("version", 0)
         return cls(
             objective=d.get("objective", ""),
             acceptance_criteria=list(d.get("acceptance_criteria", [])),
             phase=d.get("phase", "understand"),
+            plan=plan,
         )
 
     def anchor_text(self) -> str:

{drydock_cli-3.0.129 → drydock_cli-3.0.132}/drydock/tool_registry.py

@@ -30,17 +30,34 @@ def schemas() -> list[dict]:
     return [t.schema for t in _registry.values()]
 
 def execute(name: str, params: dict, config: dict, max_output: int = 32000) -> str:
-    """Execute a tool by name. Truncates large output."""
+    """Execute a tool by name. Truncates large output. Returns the text string
+    (backward-compatible); use execute_structured() for the ToolResult."""
+    return execute_structured(name, params, config, max_output).text
+
+
+def execute_structured(name: str, params: dict, config: dict, max_output: int = 32000):
+    """Execute a tool and return a structured ToolResult (status/diagnostics/
+    retryable/duration + the text), classified from the tool's string output +
+    timing. The individual tools still return plain strings — this WRAPS them."""
+    import time as _time
+
+    from drydock.tool_result import ToolResult, classify
+
     tool = get(name)
     if tool is None:
-        return f"Error: tool '{name}' not found."
+        return ToolResult(name=name, status="not_found", error_code="not_found",
+                          text=f"Error: tool '{name}' not found.")
+    start = _time.monotonic()
     try:
         result = tool.func(params, config)
     except Exception as e:
-        return f"Error executing {name}: {e}"
+        dur = int((_time.monotonic() - start) * 1000)
+        return ToolResult(name=name, status="error", error_code="exception",
+                          text=f"Error executing {name}: {e}", duration_ms=dur)
+    dur = int((_time.monotonic() - start) * 1000)
 
     if len(result) > max_output:
         half = max_output // 2
         quarter = max_output // 4
         result = result[:half] + f"\n[... {len(result) - half - quarter} chars truncated ...]\n" + result[-quarter:]
-    return result
+    return classify(name, params, result, dur)

drydock_cli-3.0.132/drydock/tool_result.py

@@ -0,0 +1,101 @@
+"""Structured tool results (Agent-Buildout PRD, section 7.4 / "structured tool
+results"): a tool's output is not immediately reduced to a single text string —
+status, diagnostics, retryability, and timing stay available to the controller for
+loop/progress detection, verification, and recovery.
+
+Incremental by design: tools still return plain strings (no rewrite), and
+tool_registry.execute() still returns a string for full backward-compat. The new
+execute_structured() WRAPS that string into a ToolResult, classifying status/error/
+retryability from the text + timing. Logic original to Drydock.
+"""
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass, field
+
+
+@dataclass
+class ToolResult:
+    """A tool call's outcome with structure the controller can reason about."""
+    name: str
+    status: str = "ok"            # "ok" | "error" | "not_found"
+    text: str = ""               # the human/model-facing string (backward-compat)
+    changed_state: bool = False   # did it mutate files/env (Write/Edit/mutating Bash)?
+    retryable: bool = False       # transient failure worth retrying?
+    error_code: str | None = None  # coarse classification when status == error
+    exit_code: int | None = None   # for Bash, if present
+    duration_ms: int = 0
+    diagnostics: list[str] = field(default_factory=list)
+
+    def to_event(self) -> dict:
+        """Compact dict for the event log (no big blobs)."""
+        return {
+            "name": self.name, "status": self.status,
+            "changed_state": self.changed_state, "retryable": self.retryable,
+            "error_code": self.error_code, "exit_code": self.exit_code,
+            "duration_ms": self.duration_ms, "result_chars": len(self.text),
+        }
+
+
+_EXIT = re.compile(r"\[exit code:\s*(-?\d+)\]")
+_MUTATING_BASH = re.compile(
+    r"(?:^|[\s;&|])(?:rm|mv|cp|mkdir|touch|tee|sed\s+-i|dd|chmod|chown|ln|"
+    r"git\s+(?:commit|add|apply|checkout|reset|rm|mv)|pip\s+install|npm\s+i|"
+    r"apt|make(?:\s|$)|cargo\s+build|>|>>)\b", re.I,
+)
+# Error phrases that usually mean "try again might work" (transient).
+_RETRYABLE = re.compile(
+    r"\b(timed out|timeout|connection (refused|reset|error)|temporarily|"
+    r"try again|rate limit|EAGAIN|ETIMEDOUT|network is unreachable|"
+    r"resource temporarily unavailable|503|502|429)\b", re.I,
+)
+
+
+def _classify_error(text: str) -> tuple[str, bool]:
+    """(error_code, retryable) for an error result string."""
+    t = text.lower()
+    if _RETRYABLE.search(text):
+        return "transient", True
+    if "not found" in t or "no such file" in t or "command not found" in t:
+        return "not_found", False
+    if "permission denied" in t:
+        return "permission", False
+    if "syntax error" in t or "invalid" in t:
+        return "invalid_input", False
+    if "timed out" in t:
+        return "timeout", True
+    return "error", False
+
+
+def classify(name: str, params: dict, text: str, duration_ms: int) -> ToolResult:
+    """Build a ToolResult from a tool's (name, params, string result). Never raises."""
+    text = text if isinstance(text, str) else str(text or "")
+    r = ToolResult(name=name, text=text, duration_ms=max(0, int(duration_ms)))
+
+    m = _EXIT.search(text)
+    if m:
+        try:
+            r.exit_code = int(m.group(1))
+        except ValueError:
+            pass
+
+    # Status: an "Error…" prefixed string, a "tool not found", or a non-zero Bash
+    # exit means the call did not succeed. Otherwise ok.
+    lowered = text.lstrip()[:60].lower()
+    if lowered.startswith("error: tool") and "not found" in text.lower():
+        r.status, r.error_code = "not_found", "not_found"
+    elif lowered.startswith("error"):
+        r.status = "error"
+        r.error_code, r.retryable = _classify_error(text)
+    elif r.exit_code not in (None, 0):
+        r.status = "error"
+        r.error_code, r.retryable = _classify_error(text)
+
+    # State change: Write/Edit always mutate; Bash only for mutating commands.
+    if name in ("Write", "Edit", "GitCommit", "BuildKnowledge", "GraphAdd"):
+        r.changed_state = r.status == "ok"
+    elif name == "Bash":
+        cmd = (params or {}).get("command", "") if isinstance(params, dict) else ""
+        r.changed_state = bool(_MUTATING_BASH.search(cmd)) and r.status == "ok"
+
+    return r

{drydock_cli-3.0.129 → drydock_cli-3.0.132/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.129
+Version: 3.0.132
 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.129 → drydock_cli-3.0.132}/drydock_cli.egg-info/SOURCES.txt

@@ -29,6 +29,7 @@ drydock/stig.py
 drydock/suggest.py
 drydock/task_state.py
 drydock/tool_registry.py
+drydock/tool_result.py
 drydock/tuning.py
 drydock/verification.py
 drydock/web.py
@@ -110,6 +111,7 @@ tests/test_repetition_interrupt.py
 tests/test_rmf.py
 tests/test_rmf_graph.py
 tests/test_rmf_stig_graph.py
+tests/test_rolling_plan.py
 tests/test_runaway_repetition.py
 tests/test_screenshot.py
 tests/test_server_probe.py
@@ -126,6 +128,7 @@ tests/test_todo.py
 tests/test_tool_arg_coercion.py
 tests/test_tool_arg_coercion_more.py
 tests/test_tool_arg_parsing.py
+tests/test_tool_result.py
 tests/test_tools_undo.py
 tests/test_tui.py
 tests/test_tuning.py

{drydock_cli-3.0.129 → drydock_cli-3.0.132}/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.129"
+version = "3.0.132"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

{drydock_cli-3.0.129 → drydock_cli-3.0.132}/tests/test_leaked_tool_call.py

@@ -83,8 +83,11 @@ def test_adaptive_reasoning_high_to_plan_then_low(monkeypatch):
             yield AssistantTurn("done", [], 1, 1)
 
     monkeypatch.setattr(agent_mod, "stream", fake_stream)
-    # execute() would run a real Bash; stub it to keep the test hermetic.
-    monkeypatch.setattr(agent_mod, "execute", lambda name, inp, cfg: "ok")
+    # execute would run a real Bash; stub it to keep the test hermetic. The loop
+    # now calls execute_structured (returns a ToolResult with .text).
+    from drydock.tool_result import ToolResult
+    monkeypatch.setattr(agent_mod, "execute_structured",
+                        lambda name, inp, cfg: ToolResult(name=name, text="ok"))
     st = AgentState()
     list(run("go", st, {"model": "gemma4"}, "sys"))
     # First (planning) turn high, the continuation that consumes the tool result low.

drydock_cli-3.0.132/tests/test_rolling_plan.py

@@ -0,0 +1,49 @@
+"""Rolling plan (Agent-Buildout PRD Epic C): 1 active + <=4 pending steps with
+stable ids; revisions bump the version; unchanged steps keep their id."""
+from __future__ import annotations
+
+from drydock.task_state import RollingPlan, TaskState, _step_id
+
+
+def test_stable_ids_survive_revision():
+    p = RollingPlan()
+    p.update_from_items([("read file", "done"), ("fix bug", "in_progress"), ("test", "pending")])
+    ids1 = {s["text"]: s["id"] for s in p.steps}
+    # revise: fix bug now done, test now active
+    p.update_from_items([("read file", "done"), ("fix bug", "done"), ("test", "in_progress")])
+    ids2 = {s["text"]: s["id"] for s in p.steps}
+    assert ids1["fix bug"] == ids2["fix bug"]        # same step, same id
+    assert ids1["test"] == ids2["test"]
+
+
+def test_caps_pending_to_four_plus_active():
+    p = RollingPlan()
+    items = [("active", "in_progress")] + [(f"p{i}", "pending") for i in range(8)]
+    p.update_from_items(items)
+    pend = [s for s in p.steps if s["status"] == "pending"]
+    assert len(pend) == 4 and any(s["status"] == "in_progress" for s in p.steps)
+
+
+def test_version_bumps_only_on_change():
+    p = RollingPlan()
+    assert p.update_from_items([("a", "pending")]) and p.version == 1
+    assert not p.update_from_items([("a", "pending")]) and p.version == 1   # no change
+    assert p.update_from_items([("a", "done")]) and p.version == 2
+
+
+def test_active_and_remaining():
+    p = RollingPlan()
+    p.update_from_items([("a", "done"), ("b", "in_progress"), ("c", "pending")])
+    assert p.active_step()["text"] == "b" and p.remaining() == 2
+
+
+def test_serialization_roundtrip():
+    ts = TaskState.from_objective("Do it.\n1. a\n2. b")
+    ts.plan.update_from_items([("a", "done"), ("b", "in_progress")])
+    d = ts.to_dict()
+    assert d["plan"]["version"] == 1 and len(d["plan"]["steps"]) == 2
+    assert TaskState.from_dict(d).plan.active_step()["text"] == "b"
+
+
+def test_step_id_deterministic():
+    assert _step_id("fix the bug") == _step_id("Fix The Bug ")   # case/space-insensitive

drydock_cli-3.0.132/tests/test_tool_result.py

@@ -0,0 +1,50 @@
+"""Structured tool results (Agent-Buildout PRD 7.4): execute_structured() wraps a
+tool's string output in a ToolResult (status/error/retryable/changed_state/duration)
+while execute() stays a plain string (backward compatibility)."""
+from __future__ import annotations
+
+from drydock.tool_result import ToolResult, classify
+from drydock.tools import register_all
+from drydock import tool_registry
+
+register_all()
+
+
+def test_execute_still_returns_str():
+    r = tool_registry.execute("Bash", {"command": "echo hi", "timeout": 5}, {"cwd": "/tmp"})
+    assert isinstance(r, str) and "hi" in r
+
+
+def test_structured_success():
+    r = tool_registry.execute_structured("Bash", {"command": "echo hi", "timeout": 5}, {"cwd": "/tmp"})
+    assert isinstance(r, ToolResult) and r.status == "ok" and r.duration_ms >= 0 and not r.changed_state
+
+
+def test_structured_failure_exit_code():
+    r = tool_registry.execute_structured(
+        "Bash", {"command": "python3 -c 'import sys;sys.exit(3)'", "timeout": 5}, {"cwd": "/tmp"})
+    assert r.status == "error" and r.exit_code == 3
+
+
+def test_not_found():
+    r = tool_registry.execute_structured("NoSuchTool", {}, {})
+    assert r.status == "not_found" and r.error_code == "not_found"
+
+
+def test_classify_changed_state_and_retryable():
+    assert classify("Write", {}, "wrote 10 bytes", 1).changed_state
+    assert not classify("Read", {}, "contents", 1).changed_state
+    assert classify("Bash", {"command": "touch x"}, "", 1).changed_state
+    assert not classify("Bash", {"command": "ls -la"}, "files", 1).changed_state
+    r = classify("Bash", {"command": "curl x"}, "Error: connection refused", 1)
+    assert r.status == "error" and r.retryable and r.error_code == "transient"
+
+
+def test_error_prefix_string():
+    r = classify("Edit", {}, "Error: old_string not found", 1)
+    assert r.status == "error" and not r.changed_state   # failed edit didn't mutate
+
+
+def test_to_event_is_compact():
+    ev = classify("Bash", {"command": "echo x"}, "x", 5).to_event()
+    assert ev["status"] == "ok" and "result_chars" in ev and "text" not in ev