drydock-cli 3.0.130__tar.gz → 3.0.133__tar.gz

{drydock_cli-3.0.130/drydock_cli.egg-info → drydock_cli-3.0.133}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.130
+Version: 3.0.133
 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.130 → drydock_cli-3.0.133}/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
@@ -459,10 +462,14 @@ def run(
                     _emit(state, "plan", version=state.task.plan.version,
                           steps=[(s["id"], s["status"]) for s in state.task.plan.steps])
 
-            _emit(state, "tool", name=tc["name"],
-                  input=str(tc.get("input"))[:200],
-                  result_chars=len(str(result)),
-                  error=str(result)[:80].lower().startswith("error"))
+            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.133/drydock/builtin_skills/nist-ai-rmf.md

@@ -0,0 +1,28 @@
+---
+name: nist-ai-rmf
+description: Apply the NIST AI Risk Management Framework (AI RMF 1.0) to govern, map, measure, and manage AI system risk
+---
+Help apply the NIST AI Risk Management Framework (AI RMF 1.0) to an AI system.
+This is a GOVERNANCE and risk-management task — trustworthy, responsible AI. If the
+user has not described the AI system, its purpose, data, and deployment context, ask
+for those first. Then work through the four AI RMF functions:
+
+1. GOVERN — the culture and processes for managing AI risk. Recommend policies,
+   roles/accountability, risk tolerance, and how AI risks are documented and escalated
+   across the AI lifecycle and the supply chain.
+2. MAP — establish context and identify risks. Frame the system's purpose, stakeholders,
+   and potential impacts; enumerate risks to individuals, groups, and society (bias,
+   safety, privacy, security, misuse), and the assumptions/limitations.
+3. MEASURE — analyze, assess, and track the identified risks with concrete methods and
+   metrics: evaluate the trustworthiness characteristics (valid & reliable, safe, secure
+   & resilient, accountable & transparent, explainable & interpretable, privacy-enhanced,
+   fair with harmful bias managed), and define test/monitoring procedures.
+4. MANAGE — prioritize and act on risks: treatment decisions (mitigate/transfer/avoid/
+   accept), resource allocation, incident response, and ongoing monitoring with feedback
+   into GOVERN and MAP.
+
+Be concrete: tie each recommendation to the relevant AI RMF function and the
+trustworthiness characteristics, and produce actionable next steps (owners, artifacts,
+review cadence). This is for building trustworthy AI — never for enabling misuse.
+
+AI system / context: $ARGS

drydock_cli-3.0.133/drydock/builtin_skills/nist-csf.md

@@ -0,0 +1,27 @@
+---
+name: nist-csf
+description: Assess and improve cybersecurity posture with the NIST Cybersecurity Framework (CSF) 2.0
+---
+Help apply the NIST Cybersecurity Framework (CSF) 2.0 to an organization or system.
+This is a DEFENSIVE governance and risk-management task. If the user hasn't described
+the organization, its systems, and its current controls, ask first. Then work across
+the six CSF 2.0 Functions:
+
+1. GOVERN (GV) — cybersecurity strategy, roles & responsibilities, policy, risk
+   management strategy, and oversight of the supply chain.
+2. IDENTIFY (ID) — asset management, business environment, risk assessment: know the
+   systems, data, and risks that must be protected.
+3. PROTECT (PR) — safeguards: access control, awareness & training, data security,
+   platform security, and resilience of technology.
+4. DETECT (DE) — continuous monitoring and adverse-event analysis to find incidents.
+5. RESPOND (RS) — incident management, analysis, mitigation, and communication.
+6. RECOVER (RC) — recovery planning and restoration of capabilities after an incident.
+
+For an assessment, rate the organization against the CSF Implementation Tiers
+(1 Partial → 2 Risk Informed → 3 Repeatable → 4 Adaptive) per Function, identify the
+gap between the current and target profile, and produce a prioritized improvement
+roadmap. Cite the relevant CSF Function/Category (e.g. GV.RM, ID.AM, PR.AA, DE.CM,
+RS.MA, RC.RP). Be concrete and defensive — this supports protecting systems, not
+attacking them.
+
+Organization / system / scope: $ARGS

{drydock_cli-3.0.130 → drydock_cli-3.0.133}/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.133/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.130 → drydock_cli-3.0.133/drydock_cli.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.130
+Version: 3.0.133
 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.130 → drydock_cli-3.0.133}/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
@@ -39,6 +40,8 @@ drydock/builtin_skills/ml-finetune.md
 drydock/builtin_skills/ml-metrics.md
 drydock/builtin_skills/ml-rl.md
 drydock/builtin_skills/ml-train.md
+drydock/builtin_skills/nist-ai-rmf.md
+drydock/builtin_skills/nist-csf.md
 drydock/builtin_skills/rmf-categorize.md
 drydock/builtin_skills/rmf-control.md
 drydock/builtin_skills/rmf-poam.md
@@ -127,6 +130,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.130 → drydock_cli-3.0.133}/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.130"
+version = "3.0.133"
 description = "Drydock — a local, provider-agnostic terminal coding agent for local LLMs"
 readme = "README.md"
 requires-python = ">=3.11"

{drydock_cli-3.0.130 → drydock_cli-3.0.133}/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.130 → drydock_cli-3.0.133}/tests/test_skills.py

@@ -59,6 +59,7 @@ def test_no_user_or_project_skills_yields_only_builtins(tmp_path):
         "rmf-control", "rmf-categorize", "rmf-review", "rmf-poam",
         "stig-assess", "stig-remediate",
         "ml-train", "ml-metrics", "ml-finetune", "ml-debug", "ml-rl", "ml-data",
+        "nist-ai-rmf", "nist-csf",
     }
 
 

drydock_cli-3.0.133/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