drydock-cli 2.8.20__tar.gz → 2.8.22__tar.gz

drydock_cli-2.8.22/.auto_release.lock

@@ -0,0 +1 @@
+996304

drydock_cli-2.8.22/.github/ISSUE_TEMPLATE/bug-report.yml

@@ -0,0 +1,118 @@
+name: Bug Report
+description: Tell us about a defect in DryDock
+title: "bug: "
+labels: ["bug"]
+body:
+  - type: markdown
+    attributes:
+      value: >
+        Thanks for filing a detailed bug. Fill out every section so the
+        autonomous improvement loop can reproduce, classify, and ship a fix
+        on the next 6-hour release tick.
+
+  - type: checkboxes
+    id: prechecks
+    attributes:
+      label: Pre-flight
+      description: Quick sanity checks before filing.
+      options:
+        - label: I'm on the latest released version (`pip install -U drydock-cli`)
+          required: true
+        - label: I searched existing open + closed issues for this symptom
+          required: true
+
+  - type: dropdown
+    id: component
+    attributes:
+      label: Component
+      description: Which part of DryDock is affected?
+      options:
+        - CLI / TUI
+        - ACP (Agent Client Protocol)
+        - MCP (Model Context Protocol integration)
+        - GraphRAG / retrieve tool
+        - Curiosity Layer
+        - Auto-release / cron / autonomous loop
+        - Install / packaging
+        - Other
+    validations:
+      required: true
+
+  - type: input
+    id: version
+    attributes:
+      label: DryDock version
+      description: Output of `drydock --version`.
+      placeholder: "drydock 2.8.21"
+    validations:
+      required: true
+
+  - type: input
+    id: model
+    attributes:
+      label: Model + provider
+      description: >
+        DryDock's behavior is highly model-dependent. Tell us the active
+        model name and the runtime serving it (vLLM, llama.cpp, Ollama,
+        LM Studio, OpenAI-compatible endpoint, etc.).
+      placeholder: "gemma4 (vLLM Docker on localhost:8000)"
+    validations:
+      required: true
+
+  - type: input
+    id: env
+    attributes:
+      label: OS + Python + install method
+      description: Operating system, Python version, and how DryDock was installed.
+      placeholder: "Ubuntu 22.04, Python 3.12, pip install drydock-cli"
+    validations:
+      required: true
+
+  - type: textarea
+    id: summary
+    attributes:
+      label: Summary
+      description: One or two sentences. What went wrong, in user terms.
+    validations:
+      required: true
+
+  - type: textarea
+    id: repro
+    attributes:
+      label: Reproduction steps
+      description: >
+        Exact commands, prompts, or actions that trigger the bug. Include
+        the slash command / tool / agent if relevant. Redact secrets.
+      placeholder: |
+        1. Run `drydock`
+        2. Type `/mcp add stdio foo npx -y @modelcontextprotocol/server-foo`
+        3. Type `list_mcp_resources` ...
+        4. See error
+    validations:
+      required: true
+
+  - type: textarea
+    id: expected
+    attributes:
+      label: Expected vs actual
+      description: What you expected to happen vs what actually happened.
+    validations:
+      required: true
+
+  - type: textarea
+    id: logs
+    attributes:
+      label: Logs / traceback / screenshots
+      description: >
+        Paste the relevant traceback, error message, JSON snippet, or
+        console output. For TUI rendering bugs, screenshots help most.
+        Session logs live at `~/.drydock/logs/` and `~/.vibe/logs/session/`.
+      render: shell
+
+  - type: textarea
+    id: context
+    attributes:
+      label: Anything else?
+      description: >
+        Workarounds you tried, related issues, anything you noticed about
+        when it does/doesn't reproduce. Optional.

drydock_cli-2.8.22/.github/ISSUE_TEMPLATE/config.yml

@@ -0,0 +1,8 @@
+blank_issues_enabled: false
+contact_links:
+  - name: Feature request or idea
+    url: https://github.com/fbobe321/drydock/issues/new?labels=enhancement&template=
+    about: Open an enhancement issue describing the feature you'd like to see
+  - name: Read the docs
+    url: https://github.com/fbobe321/drydock#readme
+    about: README + per-feature setup guides (MCP, Curiosity Layer, GraphRAG, etc.)

{drydock_cli-2.8.20 → drydock_cli-2.8.22}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.20
+Version: 2.8.22
 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
@@ -378,6 +378,81 @@ DryDock discovers skills from:
 3. Global `~/.drydock/skills/`
 4. Bundled skills (shipped with the package)
 
+### Math Tool
+
+DryDock ships with a `math` tool the model calls instead of doing arithmetic in its head. It's a direct built-in (NOT an MCP server — see [MCP is Dead](https://medium.com/) for why direct tools beat MCP for small bandwidth-limited models like Gemma 4). One argument, sandboxed Python expression, exact results.
+
+```
+math(expression="math.factorial(20)")          # 2432902008176640000 — exact
+math(expression="math.comb(50, 5)")            # 2118760
+math(expression="math.gcd(48, 18)")            # 6
+math(expression="statistics.stdev([2,4,4,4,5,5,7,9])")
+math(expression="Fraction(1,3) + Fraction(1,6)")  # exact 1/2
+math(expression="Decimal('0.1') + Decimal('0.2')") # exact 0.3
+math(expression="round(math.pi, 12)")
+math(expression="sum(range(1, 101))")          # 5050
+```
+
+Available names: arithmetic operators (`+ - * / // % **`), comparisons, `and / or / not`, `abs / round / min / max / sum / len / pow / divmod / range / int / float / bool`, the `math` and `statistics` modules, `Fraction`, `Decimal`. Constants: `pi`, `e`, `tau`, `inf`, `nan`. **No imports, no `open()`, no file/network access**, no attribute access outside the whitelist.
+
+Always auto-approved (read-only, side-effect free). Errors return a structured `{ok: false, error: "..."}` instead of raising.
+
+### Custom Tools
+
+Add your own built-in tools by dropping a file into one of these locations:
+
+- **Project-local:** any path listed in `config.toml`'s `tool_paths` array
+- **Global:** `~/.drydock/tools/`
+- **Bundled:** `drydock/core/tools/builtins/` (forks only)
+
+Each file should subclass `BaseTool[ArgsModel, ResultModel, ConfigModel, StateModel]` with a Pydantic args model + result model + an async `run()` generator. Auto-discovery picks up every non-underscore-prefixed `.py` in those directories. The class name auto-converts to a snake_case tool name (`MyTool` → `my_tool`).
+
+Minimum viable tool:
+
+```python
+# ~/.drydock/tools/word_count.py
+from collections.abc import AsyncGenerator
+from typing import ClassVar, final
+from pydantic import BaseModel, Field
+from drydock.core.tools.base import (
+    BaseTool, BaseToolConfig, BaseToolState, InvokeContext, ToolPermission,
+)
+from drydock.core.tools.ui import ToolCallDisplay, ToolResultDisplay, ToolUIData
+from drydock.core.types import ToolStreamEvent
+
+class WordCountArgs(BaseModel):
+    text: str = Field(description="Text to count words in")
+
+class WordCountResult(BaseModel):
+    count: int
+
+class WordCountConfig(BaseToolConfig):
+    permission: ToolPermission = ToolPermission.ALWAYS
+
+class WordCount(
+    BaseTool[WordCountArgs, WordCountResult, WordCountConfig, BaseToolState],
+    ToolUIData[WordCountArgs, WordCountResult],
+):
+    description: ClassVar[str] = "Count words in a string."
+
+    @classmethod
+    def format_call_display(cls, args): return ToolCallDisplay(summary=f"count: {args.text[:30]}")
+    @classmethod
+    def get_result_display(cls, event): return ToolResultDisplay(success=True, message=f"{event.result.count} words")
+    @classmethod
+    def get_status_text(cls): return "Counting"
+    def resolve_permission(self, args): return ToolPermission.ALWAYS
+
+    @final
+    async def run(self, args: WordCountArgs, ctx: InvokeContext | None = None
+                  ) -> AsyncGenerator[ToolStreamEvent | WordCountResult, None]:
+        yield WordCountResult(count=len(args.text.split()))
+```
+
+Restart drydock; the model now sees `word_count` in its tool list.
+
+For tools that should run as separate processes or that you want to share with other AI clients (Claude Code, Cursor, etc.), use the [MCP integration](#mcp-servers) instead — but be aware MCP burns substantial context per call (~20K tokens for tool-rich servers like Figma's), so a direct built-in is almost always the better choice for performance-sensitive local-model setups.
+
 ### MCP Servers
 
 DryDock can connect to any Model Context Protocol server. Tools from a server `foo` show up as `foo__<tool_name>` in the agent's tool list. Two ways to add one:

{drydock_cli-2.8.20 → drydock_cli-2.8.22}/README.md

@@ -323,6 +323,81 @@ DryDock discovers skills from:
 3. Global `~/.drydock/skills/`
 4. Bundled skills (shipped with the package)
 
+### Math Tool
+
+DryDock ships with a `math` tool the model calls instead of doing arithmetic in its head. It's a direct built-in (NOT an MCP server — see [MCP is Dead](https://medium.com/) for why direct tools beat MCP for small bandwidth-limited models like Gemma 4). One argument, sandboxed Python expression, exact results.
+
+```
+math(expression="math.factorial(20)")          # 2432902008176640000 — exact
+math(expression="math.comb(50, 5)")            # 2118760
+math(expression="math.gcd(48, 18)")            # 6
+math(expression="statistics.stdev([2,4,4,4,5,5,7,9])")
+math(expression="Fraction(1,3) + Fraction(1,6)")  # exact 1/2
+math(expression="Decimal('0.1') + Decimal('0.2')") # exact 0.3
+math(expression="round(math.pi, 12)")
+math(expression="sum(range(1, 101))")          # 5050
+```
+
+Available names: arithmetic operators (`+ - * / // % **`), comparisons, `and / or / not`, `abs / round / min / max / sum / len / pow / divmod / range / int / float / bool`, the `math` and `statistics` modules, `Fraction`, `Decimal`. Constants: `pi`, `e`, `tau`, `inf`, `nan`. **No imports, no `open()`, no file/network access**, no attribute access outside the whitelist.
+
+Always auto-approved (read-only, side-effect free). Errors return a structured `{ok: false, error: "..."}` instead of raising.
+
+### Custom Tools
+
+Add your own built-in tools by dropping a file into one of these locations:
+
+- **Project-local:** any path listed in `config.toml`'s `tool_paths` array
+- **Global:** `~/.drydock/tools/`
+- **Bundled:** `drydock/core/tools/builtins/` (forks only)
+
+Each file should subclass `BaseTool[ArgsModel, ResultModel, ConfigModel, StateModel]` with a Pydantic args model + result model + an async `run()` generator. Auto-discovery picks up every non-underscore-prefixed `.py` in those directories. The class name auto-converts to a snake_case tool name (`MyTool` → `my_tool`).
+
+Minimum viable tool:
+
+```python
+# ~/.drydock/tools/word_count.py
+from collections.abc import AsyncGenerator
+from typing import ClassVar, final
+from pydantic import BaseModel, Field
+from drydock.core.tools.base import (
+    BaseTool, BaseToolConfig, BaseToolState, InvokeContext, ToolPermission,
+)
+from drydock.core.tools.ui import ToolCallDisplay, ToolResultDisplay, ToolUIData
+from drydock.core.types import ToolStreamEvent
+
+class WordCountArgs(BaseModel):
+    text: str = Field(description="Text to count words in")
+
+class WordCountResult(BaseModel):
+    count: int
+
+class WordCountConfig(BaseToolConfig):
+    permission: ToolPermission = ToolPermission.ALWAYS
+
+class WordCount(
+    BaseTool[WordCountArgs, WordCountResult, WordCountConfig, BaseToolState],
+    ToolUIData[WordCountArgs, WordCountResult],
+):
+    description: ClassVar[str] = "Count words in a string."
+
+    @classmethod
+    def format_call_display(cls, args): return ToolCallDisplay(summary=f"count: {args.text[:30]}")
+    @classmethod
+    def get_result_display(cls, event): return ToolResultDisplay(success=True, message=f"{event.result.count} words")
+    @classmethod
+    def get_status_text(cls): return "Counting"
+    def resolve_permission(self, args): return ToolPermission.ALWAYS
+
+    @final
+    async def run(self, args: WordCountArgs, ctx: InvokeContext | None = None
+                  ) -> AsyncGenerator[ToolStreamEvent | WordCountResult, None]:
+        yield WordCountResult(count=len(args.text.split()))
+```
+
+Restart drydock; the model now sees `word_count` in its tool list.
+
+For tools that should run as separate processes or that you want to share with other AI clients (Claude Code, Cursor, etc.), use the [MCP integration](#mcp-servers) instead — but be aware MCP burns substantial context per call (~20K tokens for tool-rich servers like Figma's), so a direct built-in is almost always the better choice for performance-sensitive local-model setups.
+
 ### MCP Servers
 
 DryDock can connect to any Model Context Protocol server. Tools from a server `foo` show up as `foo__<tool_name>` in the agent's tool list. Two ways to add one:

{drydock_cli-2.8.20 → drydock_cli-2.8.22}/drydock/core/prompts/gemma4.md

@@ -79,6 +79,18 @@ Workflow for fixing bugs:
 3. Fix with search_replace
 4. Verify the fix
 
+CORE PRINCIPLES (the four lines that win):
+1. Don't assume. Don't hide confusion. Surface tradeoffs.
+2. Minimum code that solves the problem. Nothing speculative.
+3. Touch only what you must. Clean up only your own mess.
+4. Define success criteria. Loop until verified.
+
+USE THE math TOOL for any non-trivial arithmetic. Gemma 4 gets factorials,
+large multiplies, prime tests, and floating-point edge cases wrong from
+prior alone. The math tool is sandboxed Python (`math.factorial(20)`,
+`math.comb(50,5)`, `Fraction(1,3)+Fraction(1,6)`, `statistics.mean([...])`)
+and returns exact results. Use it. Don't compute in your head.
+
 Rules:
 - Create files immediately. Do not plan or discuss — write code.
 - Use absolute imports for Python packages

drydock_cli-2.8.22/drydock/core/tools/builtins/math_tool.py

@@ -0,0 +1,248 @@
+"""Math tool — exact arithmetic, statistics, and number theory via the
+Python stdlib, exposed as a single direct built-in (NOT an MCP server).
+
+Why a built-in instead of MCP:
+
+- MCP servers add a protocol layer + subprocess and burn ~20K context tokens
+  every call (Babich, "MCP is Dead", Apr 2026). For a small bandwidth-limited
+  local model like Gemma 4 (131K context) that's a real cost.
+- A direct built-in has tight, schema-enforced inputs (Pydantic), zero IPC,
+  and cannot be hijacked by injected instructions the way a tool-rich MCP
+  server can.
+- The operations the model actually wants — factorial, prime test,
+  statistics, exact fractions, large multiplies — are all stdlib and
+  compose cleanly into a single safe expression evaluator.
+
+The interface is deliberately ONE input: a Python-style expression evaluated
+in a sandbox (math.*, statistics.*, Fraction, Decimal, basic operators,
+no imports, no attribute access outside the whitelist). This keeps the tool
+list small (one entry, not twenty) and lets the model express any computation
+it might want without us having to enumerate every operation.
+
+Examples the model can call:
+
+    math(expression="2 + 3 * 4")
+    math(expression="math.factorial(20)")
+    math(expression="math.comb(50, 5)")
+    math(expression="math.gcd(48, 18)")
+    math(expression="statistics.mean([1, 2, 3, 4, 5])")
+    math(expression="statistics.stdev([2, 4, 4, 4, 5, 5, 7, 9])")
+    math(expression="Fraction(1, 3) + Fraction(1, 6)")
+    math(expression="round(math.pi, 8)")
+    math(expression="sum(range(1, 101))")     # 5050
+
+Read-only, side-effect free, always auto-approved.
+"""
+from __future__ import annotations
+
+import ast
+import math
+import statistics
+from collections.abc import AsyncGenerator
+from decimal import Decimal, getcontext
+from fractions import Fraction
+from typing import TYPE_CHECKING, Any, ClassVar, final
+
+from pydantic import BaseModel, Field
+
+from drydock.core.tools.base import (
+    BaseTool,
+    BaseToolConfig,
+    BaseToolState,
+    InvokeContext,
+    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
+
+
+# ── Safe expression evaluator ─────────────────────────────────────────
+# Whitelist nodes + names so the model can't import os / open files /
+# subprocess. Everything goes through `math.*`, `statistics.*`,
+# `Fraction`, `Decimal` plus basic operators and a small builtins set.
+
+_ALLOWED_NODES = {
+    ast.Expression, ast.Constant,
+    ast.BinOp, ast.UnaryOp, ast.BoolOp, ast.Compare,
+    ast.Add, ast.Sub, ast.Mult, ast.Div, ast.FloorDiv, ast.Mod, ast.Pow,
+    ast.USub, ast.UAdd, ast.And, ast.Or, ast.Not,
+    ast.Eq, ast.NotEq, ast.Lt, ast.LtE, ast.Gt, ast.GtE,
+    ast.Call, ast.Name, ast.Load, ast.Attribute,
+    ast.Tuple, ast.List, ast.Subscript, ast.Slice, ast.Index,
+}
+
+_ALLOWED_NAMES: dict[str, Any] = {
+    "pi": math.pi,
+    "e": math.e,
+    "tau": math.tau,
+    "inf": math.inf,
+    "nan": math.nan,
+    "abs": abs, "round": round, "min": min, "max": max, "sum": sum,
+    "len": len, "pow": pow, "divmod": divmod,
+    "int": int, "float": float, "bool": bool, "complex": complex,
+    "list": list, "tuple": tuple, "range": range,
+    "math": math,
+    "statistics": statistics,
+    "Fraction": Fraction,
+    "Decimal": Decimal,
+}
+
+_MAX_EXPR_LEN = 4000
+
+
+def _validate_ast(node: ast.AST) -> None:
+    for child in ast.walk(node):
+        if type(child) not in _ALLOWED_NODES:
+            raise ValueError(
+                f"disallowed expression node: {type(child).__name__}"
+            )
+        if isinstance(child, ast.Attribute):
+            if not (
+                isinstance(child.value, ast.Name)
+                and child.value.id in {"math", "statistics", "Fraction", "Decimal"}
+            ):
+                raise ValueError(
+                    "attribute access only allowed on math, statistics, "
+                    "Fraction, Decimal"
+                )
+        if isinstance(child, ast.Name) and child.id not in _ALLOWED_NAMES:
+            raise ValueError(f"disallowed name: {child.id}")
+
+
+def safe_eval(expression: str) -> Any:
+    """Evaluate `expression` in a sandboxed environment.
+
+    Raises ValueError on anything beyond arithmetic + math/statistics +
+    Fraction/Decimal. Callers should catch and surface the error string
+    rather than re-raising — see `MathTool.run`.
+    """
+    if len(expression) > _MAX_EXPR_LEN:
+        raise ValueError(
+            f"expression too long ({len(expression)} > {_MAX_EXPR_LEN})"
+        )
+    tree = ast.parse(expression, mode="eval")
+    _validate_ast(tree)
+    return eval(  # noqa: S307 — sandboxed via _validate_ast
+        compile(tree, "<safe_eval>", "eval"),
+        {"__builtins__": {}},
+        _ALLOWED_NAMES,
+    )
+
+
+# ── Tool ───────────────────────────────────────────────────────────────
+
+
+class MathArgs(BaseModel):
+    expression: str = Field(
+        description=(
+            "A Python expression to evaluate. Whitelist: arithmetic operators "
+            "(+ - * / // % **), comparisons, and/or/not, abs/round/min/max/"
+            "sum/len/pow/divmod/range/int/float/bool, the math module "
+            "(math.factorial, math.gcd, math.comb, math.sqrt, etc.), the "
+            "statistics module (statistics.mean, statistics.stdev, ...), "
+            "Fraction(num, den), Decimal('...'). Constants: pi, e, tau, "
+            "inf, nan. NO imports, NO open(), NO file/network access, NO "
+            "attribute access outside math/statistics/Fraction/Decimal."
+        )
+    )
+    decimal_precision: int = Field(
+        default=28,
+        ge=1,
+        le=200,
+        description=(
+            "Decimal context precision (digits). Only matters when the "
+            "expression uses `Decimal(...)`. Default 28."
+        ),
+    )
+
+
+class MathResult(BaseModel):
+    ok: bool
+    result: str = ""        # str so Fraction/Decimal/int-precision survive JSON
+    result_type: str = ""   # "int" / "float" / "Fraction" / "Decimal" / "list" / etc.
+    error: str = ""
+
+
+class MathConfig(BaseToolConfig):
+    permission: ToolPermission = ToolPermission.ALWAYS
+
+
+class Math(
+    BaseTool[MathArgs, MathResult, MathConfig, BaseToolState],
+    ToolUIData[MathArgs, MathResult],
+):
+    description: ClassVar[str] = (
+        "Evaluate exact-math expressions via Python's stdlib (math, "
+        "statistics, Fraction, Decimal). Use INSTEAD of doing arithmetic "
+        "in your head when the answer needs to be exact: factorials "
+        "above 12!, large multiplies, prime tests, modular arithmetic, "
+        "GCD/LCM, statistics, exact fractions. One arg: `expression`. "
+        "Examples: math.factorial(20), math.comb(50, 5), "
+        "statistics.mean([1,2,3]), Fraction(1,3) + Fraction(1,6). "
+        "Sandboxed — no imports, no file/network access."
+    )
+
+    @classmethod
+    def format_call_display(cls, args: MathArgs) -> ToolCallDisplay:
+        e = args.expression.strip()
+        if len(e) > 60:
+            e = e[:57] + "..."
+        return ToolCallDisplay(summary=f"math: {e}")
+
+    @classmethod
+    def get_result_display(cls, event: "ToolResultEvent") -> ToolResultDisplay:
+        if isinstance(event.result, MathResult):
+            if not event.result.ok:
+                return ToolResultDisplay(
+                    success=False,
+                    message=f"math: {event.result.error[:80]}",
+                )
+            preview = event.result.result
+            if len(preview) > 80:
+                preview = preview[:77] + "..."
+            return ToolResultDisplay(success=True, message=f"= {preview}")
+        return ToolResultDisplay(success=True, message="math complete")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Computing"
+
+    def resolve_permission(self, args: MathArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: MathArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | MathResult, None]:
+        if args.decimal_precision and args.decimal_precision != 28:
+            getcontext().prec = args.decimal_precision
+        try:
+            value = safe_eval(args.expression)
+        except SyntaxError as e:
+            yield MathResult(
+                ok=False, error=f"SyntaxError: {e.msg} at column {e.offset or '?'}"
+            )
+            return
+        except ZeroDivisionError as e:
+            yield MathResult(ok=False, error=f"ZeroDivisionError: {e}")
+            return
+        except (ValueError, OverflowError, ArithmeticError, TypeError) as e:
+            yield MathResult(ok=False, error=f"{type(e).__name__}: {e}")
+            return
+
+        # Coerce non-JSON-friendly values to strings without losing exactness.
+        if isinstance(value, (Fraction, Decimal)):
+            yield MathResult(
+                ok=True, result=str(value), result_type=type(value).__name__
+            )
+            return
+        # Plain numbers / lists / tuples / bools — repr keeps int precision
+        # for huge factorials etc.
+        yield MathResult(
+            ok=True,
+            result=repr(value) if not isinstance(value, str) else value,
+            result_type=type(value).__name__,
+        )

{drydock_cli-2.8.20 → drydock_cli-2.8.22}/drydock/core/tools/builtins/mcp_resources.py

@@ -83,13 +83,13 @@ class ListMcpResources(
                         tasks.append(list_resources_http(
                             srv.url,
                             headers=srv.headers,
-                            startup_timeout_sec=srv.startup_timeout_seconds,
+                            startup_timeout_sec=srv.startup_timeout_sec,
                         ))
                     elif isinstance(srv, MCPStdio):
                         tasks.append(list_resources_stdio(
                             srv.command,
                             env=srv.env,
-                            startup_timeout_sec=srv.startup_timeout_seconds,
+                            startup_timeout_sec=srv.startup_timeout_sec,
                         ))
 
                 if tasks:
@@ -167,13 +167,13 @@ class ReadMcpResource(
                     content = await read_resource_http(
                         srv.url, args.uri,
                         headers=srv.headers,
-                        startup_timeout_sec=srv.startup_timeout_seconds,
+                        startup_timeout_sec=srv.startup_timeout_sec,
                     )
                 elif isinstance(srv, MCPStdio):
                     content = await read_resource_stdio(
                         srv.command, args.uri,
                         env=srv.env,
-                        startup_timeout_sec=srv.startup_timeout_seconds,
+                        startup_timeout_sec=srv.startup_timeout_sec,
                     )
                 else:
                     continue

{drydock_cli-2.8.20 → drydock_cli-2.8.22}/pyproject.toml

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

{drydock_cli-2.8.20 → drydock_cli-2.8.22}/scripts/deploy_to_github.sh

@@ -41,7 +41,7 @@ AUTH_URL="https://${GITHUB_TOKEN}@github.com/fbobe321/drydock.git"
 log "Running regression tests..."
 cd "$DRYDOCK_SRC"
 $PYTHON -m pip install -q "pytest>=9.0" 2>/dev/null
-if ! $PYTHON -m pytest tests/test_drydock_regression.py tests/test_drydock_tasks.py tests/test_loop_detection.py tests/test_curiosity.py tests/test_agent_tasks.py tests/test_integration.py tests/test_user_issues.py tests/test_real_issues.py \
+if ! $PYTHON -m pytest tests/test_drydock_regression.py tests/test_drydock_tasks.py tests/test_loop_detection.py tests/test_curiosity.py tests/test_math_tool.py tests/test_agent_tasks.py tests/test_integration.py tests/test_user_issues.py tests/test_real_issues.py \
     -p no:xdist -p no:cov --override-ini="addopts=" -q 2>&1; then
     log "TESTS FAILED — deploy aborted. Fix the tests before deploying."
     exit 1