drydock-cli 2.8.47__tar.gz → 2.8.48__tar.gz

drydock_cli-2.8.48/.auto_release.lock

@@ -0,0 +1 @@
+2327834

{drydock_cli-2.8.47 → drydock_cli-2.8.48}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.47
+Version: 2.8.48
 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
@@ -40,6 +40,7 @@ Requires-Dist: pydantic-settings>=2.12.0
 Requires-Dist: pydantic>=2.12.4
 Requires-Dist: pypdf>=4.0.0
 Requires-Dist: pyperclip>=1.11.0
+Requires-Dist: pytholog>=2.4.1
 Requires-Dist: pyyaml>=6.0.0
 Requires-Dist: rich>=14.0.0
 Requires-Dist: textual-speedups>=0.2.1

{drydock_cli-2.8.47 → drydock_cli-2.8.48}/drydock/core/prompts/gemma4.md

@@ -4,7 +4,7 @@ ACT IMMEDIATELY. Your FIRST response must be a tool call — not text. Do NOT ex
 
 When answering a direct factual or math question (not writing code), you MUST write visible text — never produce a response with only thinking tokens and no visible content. End your response with "FINAL ANSWER: <your answer>" on its own line so the judge can extract it. Even if you are uncertain, always attempt an answer and write "FINAL ANSWER: <best guess>" — an empty response scores 0 regardless of how good your reasoning was.
 
-Your tools: read_file, write_file, search_replace, grep, glob, bash, task, web_search, web_fetch, retrieve, math, count, memory, verify, logic, algebra, number_theory, set, linear_algebra, stats, units, chemistry, solve.
+Your tools: read_file, write_file, search_replace, grep, glob, bash, task, web_search, web_fetch, retrieve, math, count, memory, verify, logic, algebra, number_theory, set, linear_algebra, stats, units, chemistry, solve, prolog.
 
 CURIOSITY — default posture is "investigate, then assert" (SOVEREIGN_PRD §5.7):
 - If the user message names a thing you don't have context for (paper title,
@@ -252,6 +252,33 @@ Reach for solve when the question has the shape:
 - "smallest / largest / maximize / minimize ... subject to ..."
 - "prove X from Y, Z" with constraints over integers/reals/booleans
 
+USE THE prolog TOOL for SYMBOLIC LOGIC + RELATION problems — where
+the question is about facts and rules, not arithmetic. Different
+strengths than solve (Z3):
+  prolog(op="query",
+         facts=["parent(tom, bob)", "parent(bob, ann)", "parent(bob, pat)"],
+         rules=["grandparent(X, Y) :- parent(X, Z), parent(Z, Y)"],
+         query="grandparent(tom, X)")
+    → [{"X": "ann"}, {"X": "pat"}]
+  prolog(op="query",
+         facts=["parent(a,b)", "parent(b,c)", "parent(c,d)"],
+         rules=["ancestor(X,Y) :- parent(X,Y)",
+                "ancestor(X,Y) :- parent(X,Z), ancestor(Z,Y)"],
+         query="ancestor(a, X)")
+    → [{"X":"b"}, {"X":"c"}, {"X":"d"}]
+Standard Prolog syntax: lowercase atoms, UPPERCASE variables,
+`name(arg1, arg2)` predicates, `head(X) :- body1(X), body2(X)` rules.
+Use INSTEAD of reasoning through transitive/recursive relations by
+hand. Z3 (solve) is for arithmetic constraints; prolog is for
+symbolic logic + relations.
+
+Reach for prolog when the question has the shape:
+- "X is the parent/cousin/ancestor of Y" + similar relation questions
+- "If A then B" rules + "is C true?" queries
+- Family tree / who-knows-who / who-likes-what puzzles
+- Recursive definitions over discrete structures
+- "All X such that R(X, Y) holds" enumeration
+
 Rules:
 - Create files immediately. Do not plan or discuss — write code.
 - Use absolute imports for Python packages

drydock_cli-2.8.48/drydock/core/tools/builtins/prolog_tool.py

@@ -0,0 +1,325 @@
+"""Prolog tool — logic-programming via pytholog (pure-Python).
+
+Companion to `solve` (Z3 / SMT): where Z3 reasons over arithmetic +
+boolean constraints, Prolog reasons over facts and rules with
+unification + backtracking. Strengths:
+
+  - Family/relation puzzles (parent/grandparent/uncle/...)
+  - Logic puzzles with rules like "if X then Y, if Y then Z"
+  - Recursive predicates (Fibonacci, ancestor, path-finding)
+  - "All X such that R(X, Y) holds" queries
+
+Why pytholog instead of swipl: the user's deployment constraint is
+"pip-installable, no system install". pytholog (pip install pytholog)
+covers the Horn-clause + unification subset of Prolog. CLP / DCG /
+arithmetic-heavy work should still go to `solve`.
+
+Operations (`op=`):
+
+  query(facts, rules, query)
+      Run a single query against the given KB. Returns the list of
+      variable bindings that satisfy the query, or `[]` for no match,
+      or `["Yes"]` for a ground query that holds with no variables.
+
+  consult(facts, rules)
+      Validate that the KB compiles. Useful as a dry-run before
+      issuing real queries. Returns "ok" or an error message.
+
+  assert_and_query(facts, rules, query)
+      Same as query but also returns the KB size (fact + rule count)
+      so the model can see how big the program got.
+
+Input syntax — standard Prolog (pytholog dialect):
+    facts:  ["parent(tom, bob)", "parent(bob, ann)", ...]
+    rules:  ["grandparent(X, Y) :- parent(X, Z), parent(Z, Y)", ...]
+    query:  "grandparent(tom, X)"
+
+Lowercase identifiers are atoms; uppercase identifiers are variables.
+
+Read-only, side-effect free, ALWAYS permission. Hard-bounded:
+  - Max 200 facts + 50 rules per call (KB build is O(n) so larger
+    KBs work but tax context; this is a sanity ceiling).
+  - 5-second query timeout (asyncio.wait_for).
+  - Result list capped at 100 bindings (Prolog can backtrack
+    indefinitely on cyclic rules).
+"""
+from __future__ import annotations
+
+import asyncio
+import logging
+from collections.abc import AsyncGenerator
+from typing import TYPE_CHECKING, ClassVar, Literal, final
+
+from pydantic import BaseModel, Field
+
+from drydock.core.tools.base import (
+    BaseTool,
+    BaseToolConfig,
+    BaseToolState,
+    InvokeContext,
+    ToolError,
+    ToolPermission,
+)
+from drydock.core.tools.ui import (
+    ToolCallDisplay,
+    ToolResultDisplay,
+    ToolUIData,
+)
+from drydock.core.types import ToolStreamEvent
+
+if TYPE_CHECKING:
+    from drydock.core.types import ToolResultEvent
+
+logger = logging.getLogger("drydock.prolog")
+
+
+PrologOp = Literal["query", "consult", "assert_and_query"]
+
+
+_OP_HELP = (
+    "Operation: query (run a query against facts+rules), consult "
+    "(validate the KB compiles without querying), assert_and_query "
+    "(same as query but also returns KB size)."
+)
+
+
+class PrologArgs(BaseModel):
+    op: PrologOp = Field(description=_OP_HELP)
+    facts: list[str] = Field(
+        default_factory=list,
+        description=(
+            'Ground facts, one per entry. Standard Prolog syntax: '
+            '`parent(tom, bob)`, `likes(alice, pizza)`. Lowercase '
+            'atoms, no trailing period. Max 200.'
+        ),
+    )
+    rules: list[str] = Field(
+        default_factory=list,
+        description=(
+            'Inference rules, one per entry. Standard Prolog syntax: '
+            '`grandparent(X, Y) :- parent(X, Z), parent(Z, Y)`. '
+            'Uppercase identifiers are variables. Max 50.'
+        ),
+    )
+    query: str = Field(
+        default="",
+        description=(
+            'Single query to run (e.g. `grandparent(tom, X)`). Variables '
+            'in the query become the unknowns to solve for. Ignored by '
+            '`consult`.'
+        ),
+    )
+    timeout_sec: float = Field(
+        default=5.0,
+        ge=0.5,
+        le=30.0,
+        description="Query timeout in seconds. Default 5.",
+    )
+
+
+class PrologResult(BaseModel):
+    ok: bool
+    op: str = ""
+    bindings: list[dict] = Field(default_factory=list)
+    # Convenience: "Yes" / "No" string for ground (no-variables) queries
+    # or 0 bindings.
+    summary: str = ""
+    kb_size: int = 0  # facts + rules count
+    error: str = ""
+
+
+class PrologConfig(BaseToolConfig):
+    permission: ToolPermission = ToolPermission.ALWAYS
+
+
+# ── Validation ─────────────────────────────────────────────────────────
+
+_MAX_FACTS = 200
+_MAX_RULES = 50
+_MAX_LEN_PER_ENTRY = 1000
+
+
+_FORBIDDEN_TOKENS = (
+    "import", "exec", "eval", "open(", "__",
+    "globals", "locals", "getattr",
+)
+
+
+def _validate_kb(facts: list[str], rules: list[str]) -> None:
+    if len(facts) > _MAX_FACTS:
+        raise ToolError(f"too many facts ({len(facts)} > {_MAX_FACTS})")
+    if len(rules) > _MAX_RULES:
+        raise ToolError(f"too many rules ({len(rules)} > {_MAX_RULES})")
+    for kind, items in (("fact", facts), ("rule", rules)):
+        for entry in items:
+            if not entry or not entry.strip():
+                continue  # skip empty
+            if len(entry) > _MAX_LEN_PER_ENTRY:
+                raise ToolError(
+                    f"{kind} too long ({len(entry)} chars > {_MAX_LEN_PER_ENTRY})"
+                )
+            low = entry.lower()
+            for bad in _FORBIDDEN_TOKENS:
+                if bad in low:
+                    raise ToolError(f"forbidden token {bad!r} in {kind}: {entry!r}")
+
+
+def _build_kb(facts: list[str], rules: list[str]):
+    """Compile a pytholog KnowledgeBase from the inputs."""
+    import pytholog as pl
+    kb = pl.KnowledgeBase("drydock_session")
+    # pytholog accepts a single list of facts and rules together.
+    program = [f.strip() for f in facts if f.strip()] + \
+              [r.strip() for r in rules if r.strip()]
+    if not program:
+        raise ToolError("empty knowledge base (no facts or rules)")
+    try:
+        kb(program)
+    except Exception as e:
+        raise ToolError(f"KB compile error: {type(e).__name__}: {e}") from e
+    return kb
+
+
+def _run_query_sync(kb, query_str: str) -> tuple[list[dict], str]:
+    """Execute a single query.
+
+    Returns (bindings, summary):
+      - bindings: list of {var:value} dicts (empty for ground or no-match)
+      - summary: 'Yes' / 'No' for ground queries; 'N solution(s)' otherwise
+    """
+    import pytholog as pl
+    try:
+        result = kb.query(pl.Expr(query_str.strip()))
+    except Exception as e:
+        raise ToolError(f"query error: {type(e).__name__}: {e}") from e
+
+    # pytholog returns a LIST in all cases:
+    #   - [{'X': 'val'}, ...] for variable queries
+    #   - ['Yes'] for ground match
+    #   - ['No'] for no match
+    # Normalise to (list-of-dicts, summary-string).
+    if not isinstance(result, list):
+        # Defensive: future pytholog versions might return scalars
+        return ([], str(result))
+    if not result:
+        return ([], "No")
+    # Single-element string result is ground YES / NO
+    if len(result) == 1 and isinstance(result[0], str):
+        return ([], result[0])
+    # Variable bindings — list of dicts. Cap at 100 to avoid blowing
+    # the token budget on cyclic rules.
+    bindings = [b for b in result if isinstance(b, dict)][:100]
+    return (bindings, f"{len(bindings)} solution(s)" if bindings else "No")
+
+
+# ── Dispatch ───────────────────────────────────────────────────────────
+
+async def _op_query(args: PrologArgs) -> PrologResult:
+    if not args.query.strip():
+        raise ToolError("`query` is empty")
+    _validate_kb(args.facts, args.rules)
+    kb = _build_kb(args.facts, args.rules)
+
+    async def _go():
+        return _run_query_sync(kb, args.query)
+
+    try:
+        bindings, summary = await asyncio.wait_for(_go(), timeout=args.timeout_sec)
+    except asyncio.TimeoutError as e:
+        raise ToolError(
+            f"query timeout after {args.timeout_sec}s — narrow the "
+            f"query, add more constraints, or check for cyclic rules"
+        ) from e
+
+    return PrologResult(
+        ok=True, op="query", bindings=bindings, summary=summary,
+        kb_size=len(args.facts) + len(args.rules),
+    )
+
+
+async def _op_consult(args: PrologArgs) -> PrologResult:
+    _validate_kb(args.facts, args.rules)
+    _build_kb(args.facts, args.rules)
+    return PrologResult(
+        ok=True, op="consult", summary="ok",
+        kb_size=len(args.facts) + len(args.rules),
+    )
+
+
+async def _op_assert_and_query(args: PrologArgs) -> PrologResult:
+    r = await _op_query(args)
+    r.op = "assert_and_query"
+    return r
+
+
+_DISPATCH = {
+    "query":            _op_query,
+    "consult":          _op_consult,
+    "assert_and_query": _op_assert_and_query,
+}
+
+
+class Prolog(
+    BaseTool[PrologArgs, PrologResult, PrologConfig, BaseToolState],
+    ToolUIData[PrologArgs, PrologResult],
+):
+    description: ClassVar[str] = (
+        "Logic-programming via pytholog (pure-Python Prolog). When "
+        "you have facts + rules and need to query relations, use this "
+        "INSTEAD of trying to reason about transitive / recursive "
+        "relations by hand. Strengths: family/relation puzzles, "
+        "ancestor / path-finding, all-solutions enumeration, "
+        "horn-clause inference. Operations: query, consult, "
+        "assert_and_query. Standard Prolog syntax — lowercase atoms, "
+        "UPPERCASE variables, `name(arg1, arg2)` predicates, "
+        "`head(X) :- body1(X), body2(X)` rules. For arithmetic / "
+        "constraint problems use `solve` (Z3) instead — Prolog is "
+        "for symbolic logic and relations."
+    )
+
+    @classmethod
+    def format_call_display(cls, args: PrologArgs) -> ToolCallDisplay:
+        q = args.query.strip()[:40] or "(consult)"
+        return ToolCallDisplay(
+            summary=f"prolog[{args.op}]: {len(args.facts)}f+{len(args.rules)}r → {q}"
+        )
+
+    @classmethod
+    def get_result_display(cls, event: "ToolResultEvent") -> ToolResultDisplay:
+        if isinstance(event.result, PrologResult):
+            if not event.result.ok:
+                return ToolResultDisplay(
+                    success=False, message=f"prolog: {event.result.error[:80]}"
+                )
+            return ToolResultDisplay(
+                success=True,
+                message=f"{event.result.summary}",
+            )
+        return ToolResultDisplay(success=True, message="prolog complete")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Reasoning with Prolog"
+
+    def resolve_permission(self, args: PrologArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: PrologArgs, ctx: "InvokeContext | None" = None
+    ) -> AsyncGenerator["ToolStreamEvent | PrologResult", None]:
+        handler = _DISPATCH.get(args.op)
+        if handler is None:
+            yield PrologResult(
+                ok=False, op=args.op,
+                error=f"unknown op {args.op!r}. Allowed: {list(_DISPATCH)}",
+            )
+            return
+        try:
+            yield await handler(args)
+        except ToolError as e:
+            yield PrologResult(ok=False, op=args.op, error=str(e))
+        except Exception as e:  # noqa: BLE001 — surface to model, don't crash
+            yield PrologResult(
+                ok=False, op=args.op, error=f"{type(e).__name__}: {e}"
+            )

{drydock_cli-2.8.47 → drydock_cli-2.8.48}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "drydock-cli"
-version = "2.8.47"
+version = "2.8.48"
 description = "Local-first CLI coding agent — tested with Gemma 4 26B via vLLM"
 readme = "README.md"
 requires-python = ">=3.12"
@@ -49,6 +49,7 @@ dependencies = [
     "pydantic-settings>=2.12.0",
     "pypdf>=4.0.0",
     "pyperclip>=1.11.0",
+    "pytholog>=2.4.1",
     "pyyaml>=6.0.0",
     "rich>=14.0.0",
     "textual>=7.4.0",

drydock_cli-2.8.48/tests/test_prolog_tool.py

@@ -0,0 +1,205 @@
+"""Tests for the prolog built-in tool (pytholog-backed)."""
+from __future__ import annotations
+
+import asyncio
+
+import pytest
+
+from drydock.core.tools.base import BaseToolState
+from drydock.core.tools.builtins.prolog_tool import (
+    Prolog,
+    PrologArgs,
+    PrologConfig,
+    PrologResult,
+    _build_kb,
+    _validate_kb,
+)
+
+
+def _drive(args: PrologArgs) -> PrologResult:
+    tool = Prolog(config=PrologConfig(), state=BaseToolState())
+
+    async def go() -> PrologResult:
+        result = None
+        async for ev in tool.run(args):
+            if isinstance(ev, PrologResult):
+                result = ev
+        assert result is not None
+        return result
+
+    return asyncio.run(go())
+
+
+# ── query ───────────────────────────────────────────────────────────────
+
+def test_query_family_relations():
+    r = _drive(PrologArgs(
+        op="query",
+        facts=["parent(tom, bob)", "parent(bob, ann)", "parent(bob, pat)"],
+        rules=["grandparent(X, Y) :- parent(X, Z), parent(Z, Y)"],
+        query="grandparent(tom, X)",
+    ))
+    assert r.ok
+    xs = {b["X"] for b in r.bindings}
+    assert xs == {"ann", "pat"}
+
+
+def test_query_ground_yes():
+    r = _drive(PrologArgs(
+        op="query",
+        facts=["likes(alice, pizza)"],
+        query="likes(alice, pizza)",
+    ))
+    assert r.ok
+    assert r.summary == "Yes"
+    assert r.bindings == []
+
+
+def test_query_ground_no():
+    r = _drive(PrologArgs(
+        op="query",
+        facts=["likes(alice, pizza)"],
+        query="likes(alice, salad)",
+    ))
+    assert r.ok
+    assert r.summary == "No"
+    assert r.bindings == []
+
+
+def test_query_recursive_ancestor():
+    r = _drive(PrologArgs(
+        op="query",
+        facts=["parent(a, b)", "parent(b, c)", "parent(c, d)"],
+        rules=[
+            "ancestor(X, Y) :- parent(X, Y)",
+            "ancestor(X, Y) :- parent(X, Z), ancestor(Z, Y)",
+        ],
+        query="ancestor(a, X)",
+    ))
+    assert r.ok
+    xs = {b["X"] for b in r.bindings}
+    assert xs == {"b", "c", "d"}
+
+
+def test_query_summary_counts_solutions():
+    r = _drive(PrologArgs(
+        op="query",
+        facts=["color(red)", "color(green)", "color(blue)"],
+        query="color(X)",
+    ))
+    assert r.ok
+    assert r.summary == "3 solution(s)"
+    assert len(r.bindings) == 3
+
+
+# ── consult ─────────────────────────────────────────────────────────────
+
+def test_consult_validates_kb_compiles():
+    r = _drive(PrologArgs(
+        op="consult",
+        facts=["foo(1)", "foo(2)", "bar(baz)"],
+        rules=["q(X) :- foo(X), bar(_)"],
+    ))
+    assert r.ok
+    assert r.summary == "ok"
+    assert r.kb_size == 4  # 3 facts + 1 rule
+
+
+# ── assert_and_query ────────────────────────────────────────────────────
+
+def test_assert_and_query_returns_kb_size():
+    r = _drive(PrologArgs(
+        op="assert_and_query",
+        facts=["a(1)", "a(2)", "a(3)"],
+        query="a(X)",
+    ))
+    assert r.ok
+    assert r.op == "assert_and_query"
+    assert r.kb_size == 3
+    assert len(r.bindings) == 3
+
+
+# ── Validation ──────────────────────────────────────────────────────────
+
+def test_query_rejects_empty_kb():
+    r = _drive(PrologArgs(op="query", facts=[], rules=[], query="foo(X)"))
+    assert not r.ok
+    assert "empty" in r.error.lower()
+
+
+def test_query_requires_query_string():
+    r = _drive(PrologArgs(op="query", facts=["foo(1)"], query=""))
+    assert not r.ok
+    assert "empty" in r.error.lower()
+
+
+@pytest.mark.parametrize("bad_token", [
+    "__import__(os)",
+    "exec('print(1)')",
+    "open('/etc/passwd')",
+    "eval('1+1')",
+])
+def test_forbidden_tokens_rejected(bad_token: str):
+    r = _drive(PrologArgs(
+        op="query", facts=[bad_token], rules=[], query="foo(X)",
+    ))
+    assert not r.ok
+    assert "forbidden" in r.error.lower()
+
+
+def test_fact_count_cap():
+    facts = [f"foo({i})" for i in range(250)]  # > 200
+    r = _drive(PrologArgs(op="query", facts=facts, query="foo(X)"))
+    assert not r.ok
+    assert "too many facts" in r.error
+
+
+def test_rule_count_cap():
+    rules = [f"r{i}(X) :- foo(X)" for i in range(60)]  # > 50
+    r = _drive(PrologArgs(
+        op="query", facts=["foo(1)"], rules=rules, query="foo(X)",
+    ))
+    assert not r.ok
+    assert "too many rules" in r.error
+
+
+def test_overlong_entry_rejected():
+    long_fact = "foo(" + "a" * 2000 + ")"
+    r = _drive(PrologArgs(op="query", facts=[long_fact], query="foo(X)"))
+    assert not r.ok
+    assert "too long" in r.error
+
+
+# ── Discovery ──────────────────────────────────────────────────────────
+
+def test_tool_is_discoverable():
+    """prolog should be auto-registered by ToolManager scanning builtins."""
+    from drydock.core.paths import DEFAULT_TOOL_DIR
+    from drydock.core.tools.manager import ToolManager
+    classes = list(ToolManager._iter_tool_classes([DEFAULT_TOOL_DIR.path]))
+    names = {c.get_name() for c in classes}
+    assert "prolog" in names
+
+
+# ── End-to-end: a small logic puzzle ────────────────────────────────────
+
+def test_small_logic_puzzle_employee_department():
+    """3 employees, 3 departments; constraints determine the assignment."""
+    r = _drive(PrologArgs(
+        op="query",
+        facts=[
+            "person(alice)", "person(bob)", "person(carol)",
+            "dept(engineering)", "dept(sales)", "dept(hr)",
+            "works_in(alice, engineering)",
+            "works_in(bob, sales)",
+            "works_in(carol, hr)",
+        ],
+        rules=[
+            "colleagues(X, Y) :- works_in(X, D), works_in(Y, D), X \\= Y",
+        ],
+        query="works_in(carol, X)",
+    ))
+    assert r.ok
+    # carol → hr
+    assert len(r.bindings) == 1
+    assert r.bindings[0]["X"] == "hr"