drydock-cli 2.8.21__tar.gz → 2.8.23__tar.gz

drydock_cli-2.8.23/.auto_release.lock

@@ -0,0 +1 @@
+1014651

drydock_cli-2.8.23/.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.23/.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.21 → drydock_cli-2.8.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 2.8.21
+Version: 2.8.23
 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
@@ -36,13 +36,11 @@ Requires-Dist: markdownify>=1.2.2
 Requires-Dist: mcp>=1.14.0
 Requires-Dist: mistralai==1.12.4
 Requires-Dist: packaging>=24.1
-Requires-Dist: pexpect>=4.9.0
 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: pyyaml>=6.0.0
-Requires-Dist: requests>=2.20.0
 Requires-Dist: rich>=14.0.0
 Requires-Dist: textual-speedups>=0.2.1
 Requires-Dist: textual>=7.4.0
@@ -378,6 +376,92 @@ DryDock discovers skills from:
 3. Global `~/.drydock/skills/`
 4. Bundled skills (shipped with the package)
 
+### Built-in tools beyond the basics
+
+In addition to the standard `read_file` / `write_file` / `search_replace` / `bash` / `grep` / `glob` / `task` / `retrieve` set, DryDock ships four direct built-ins designed to plug well-known transformer weaknesses:
+
+- **`math`** — exact arithmetic via stdlib (math, statistics, Fraction, Decimal). Sandboxed Python expression. Fixes factorials, large multiplies, primes, statistics, exact fractions.
+- **`count`** — exact substring/regex/lines/words/chars/bytes count over a string OR a file. Fixes "how many X are in this text" estimation errors.
+- **`memory`** — persistent cross-session key/value notes at `~/.drydock/agent_memory/notes.jsonl`. Save, recall (TF-IDF ranked), list keys, forget. Bridges the long-term memory gap.
+- **`verify`** — runs a shell command (or checks a file) and matches the output against an expectation (contains/not_contains/regex/equals/exit_code/file_exists/file_contains). Operationalizes the "Loop until verified" core principle.
+
+All four are direct built-ins, NOT MCP servers — per Babich's "MCP is Dead" (Apr 2026), MCP servers burn ~20K tokens of context per call which is a real cost on a 131K-context local model. Direct built-ins use a strict Pydantic schema, single subprocess-free path, and tighter security.
+
+### 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.21 → drydock_cli-2.8.23}/README.md

@@ -323,6 +323,92 @@ DryDock discovers skills from:
 3. Global `~/.drydock/skills/`
 4. Bundled skills (shipped with the package)
 
+### Built-in tools beyond the basics
+
+In addition to the standard `read_file` / `write_file` / `search_replace` / `bash` / `grep` / `glob` / `task` / `retrieve` set, DryDock ships four direct built-ins designed to plug well-known transformer weaknesses:
+
+- **`math`** — exact arithmetic via stdlib (math, statistics, Fraction, Decimal). Sandboxed Python expression. Fixes factorials, large multiplies, primes, statistics, exact fractions.
+- **`count`** — exact substring/regex/lines/words/chars/bytes count over a string OR a file. Fixes "how many X are in this text" estimation errors.
+- **`memory`** — persistent cross-session key/value notes at `~/.drydock/agent_memory/notes.jsonl`. Save, recall (TF-IDF ranked), list keys, forget. Bridges the long-term memory gap.
+- **`verify`** — runs a shell command (or checks a file) and matches the output against an expectation (contains/not_contains/regex/equals/exit_code/file_exists/file_contains). Operationalizes the "Loop until verified" core principle.
+
+All four are direct built-ins, NOT MCP servers — per Babich's "MCP is Dead" (Apr 2026), MCP servers burn ~20K tokens of context per call which is a real cost on a 131K-context local model. Direct built-ins use a strict Pydantic schema, single subprocess-free path, and tighter security.
+
+### 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.21 → drydock_cli-2.8.23}/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.23/drydock/core/tools/builtins/count_tool.py

@@ -0,0 +1,218 @@
+"""Count tool — exact substring / regex / line / token counts.
+
+The companion to the math tool: transformers can't count reliably (they
+estimate token positions and overshoot/undershoot on "how many X are in
+this text"). This tool fixes it by deferring to deterministic stdlib code.
+
+Use INSTEAD of estimating "how many" anything. The model just calls and
+gets the exact number.
+
+Modes:
+- substring      — case-sensitive substring count (default)
+- substring_ci   — case-insensitive substring count
+- regex          — regex match count (uses re.findall)
+- lines          — number of lines (newline-separated)
+- words          — whitespace-separated word count
+- chars          — total character count
+- bytes          — UTF-8 byte length
+
+Source can be:
+- `text` arg directly
+- `path` arg pointing at a file (read up to 10 MB)
+
+Examples:
+
+    count(pattern="r", text="strawberry")              # 3
+    count(pattern="def ", path="/data3/drydock/drydock/core/agent_loop.py", mode="substring")
+    count(pattern="^class\\s", path="...", mode="regex")
+    count(mode="lines", path="...")
+    count(mode="words", text="hello world hello")      # 3
+"""
+from __future__ import annotations
+
+import re
+from collections.abc import AsyncGenerator
+from pathlib import Path
+from typing import TYPE_CHECKING, ClassVar, Literal, 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
+
+
+_MAX_FILE_BYTES = 10 * 1024 * 1024  # 10 MB
+
+CountMode = Literal[
+    "substring", "substring_ci", "regex", "lines", "words", "chars", "bytes",
+]
+
+
+class CountArgs(BaseModel):
+    mode: CountMode = Field(
+        default="substring",
+        description=(
+            "How to count. `substring` = case-sensitive substring (needs "
+            "`pattern`). `substring_ci` = case-insensitive. `regex` = "
+            "Python re.findall (needs `pattern`). `lines` / `words` / "
+            "`chars` / `bytes` = pattern-free."
+        ),
+    )
+    pattern: str = Field(
+        default="",
+        description=(
+            "Required for substring / substring_ci / regex. Ignored otherwise."
+        ),
+    )
+    text: str = Field(
+        default="",
+        description=(
+            "Inline text to count in. Provide either `text` OR `path`, not both."
+        ),
+    )
+    path: str = Field(
+        default="",
+        description=(
+            "Path to a file to count in. Capped at 10 MB. Use either `text` "
+            "OR `path`."
+        ),
+    )
+
+
+class CountResult(BaseModel):
+    ok: bool
+    count: int = 0
+    mode: str = ""
+    source: str = ""    # "text" or the file path
+    error: str = ""
+
+
+class CountConfig(BaseToolConfig):
+    permission: ToolPermission = ToolPermission.ALWAYS
+
+
+def _resolve_text(args: CountArgs) -> tuple[str, str]:
+    """Returns (text, source_label). Raises ValueError on bad input.
+
+    Empty text + empty path is treated as the empty string source — valid
+    for pattern-free modes like `lines` (returns 0). Substring / regex
+    modes still error out via `_do_count` if the pattern is empty.
+    """
+    if args.text and args.path:
+        raise ValueError("provide either `text` or `path`, not both")
+    if args.path:
+        p = Path(args.path).expanduser()
+        if not p.is_file():
+            raise ValueError(f"file not found: {p}")
+        size = p.stat().st_size
+        if size > _MAX_FILE_BYTES:
+            raise ValueError(
+                f"file too large ({size} bytes > {_MAX_FILE_BYTES})"
+            )
+        return p.read_text(errors="replace"), str(p)
+    return args.text, "text"
+
+
+def _do_count(text: str, args: CountArgs) -> int:
+    if args.mode == "substring":
+        if not args.pattern:
+            raise ValueError("substring mode requires `pattern`")
+        return text.count(args.pattern)
+    if args.mode == "substring_ci":
+        if not args.pattern:
+            raise ValueError("substring_ci mode requires `pattern`")
+        return text.lower().count(args.pattern.lower())
+    if args.mode == "regex":
+        if not args.pattern:
+            raise ValueError("regex mode requires `pattern`")
+        try:
+            return len(re.findall(args.pattern, text))
+        except re.error as e:
+            raise ValueError(f"invalid regex: {e}") from e
+    if args.mode == "lines":
+        # If text ends without a newline, it still counts as one line.
+        if not text:
+            return 0
+        return text.count("\n") + (0 if text.endswith("\n") else 1)
+    if args.mode == "words":
+        return len(text.split())
+    if args.mode == "chars":
+        return len(text)
+    if args.mode == "bytes":
+        return len(text.encode("utf-8"))
+    raise ValueError(f"unknown mode: {args.mode}")
+
+
+class Count(
+    BaseTool[CountArgs, CountResult, CountConfig, BaseToolState],
+    ToolUIData[CountArgs, CountResult],
+):
+    description: ClassVar[str] = (
+        "Exact count of substrings, regex matches, lines, words, chars, "
+        "or bytes in a string OR file. Use INSTEAD of estimating 'how "
+        "many X are in this text' — transformers count poorly. Modes: "
+        "substring (default), substring_ci, regex, lines, words, chars, "
+        "bytes. Source: pass `text=...` OR `path=...` (file capped at "
+        "10 MB). Examples: count(pattern='r', text='strawberry') -> 3; "
+        "count(pattern='^def ', path='foo.py', mode='regex'); "
+        "count(mode='lines', path='foo.txt')."
+    )
+
+    @classmethod
+    def format_call_display(cls, args: CountArgs) -> ToolCallDisplay:
+        if args.path:
+            target = args.path.split("/")[-1] if "/" in args.path else args.path
+            target = f"file:{target}"
+        else:
+            preview = args.text[:30].replace("\n", " ")
+            target = f'text:"{preview}..."' if len(args.text) > 30 else f'text:"{preview}"'
+        if args.mode in ("substring", "substring_ci", "regex") and args.pattern:
+            return ToolCallDisplay(summary=f"count {args.mode} {args.pattern!r} in {target}")
+        return ToolCallDisplay(summary=f"count {args.mode} in {target}")
+
+    @classmethod
+    def get_result_display(cls, event: "ToolResultEvent") -> ToolResultDisplay:
+        if isinstance(event.result, CountResult):
+            if not event.result.ok:
+                return ToolResultDisplay(
+                    success=False, message=f"count: {event.result.error[:80]}"
+                )
+            return ToolResultDisplay(
+                success=True,
+                message=f"= {event.result.count} ({event.result.mode})",
+            )
+        return ToolResultDisplay(success=True, message="count complete")
+
+    @classmethod
+    def get_status_text(cls) -> str:
+        return "Counting"
+
+    def resolve_permission(self, args: CountArgs) -> ToolPermission | None:
+        return ToolPermission.ALWAYS
+
+    @final
+    async def run(
+        self, args: CountArgs, ctx: InvokeContext | None = None
+    ) -> AsyncGenerator[ToolStreamEvent | CountResult, None]:
+        try:
+            text, source = _resolve_text(args)
+            n = _do_count(text, args)
+        except ValueError as e:
+            yield CountResult(ok=False, error=str(e), mode=args.mode)
+            return
+        except OSError as e:
+            yield CountResult(
+                ok=False, error=f"OSError: {e}", mode=args.mode
+            )
+            return
+        yield CountResult(ok=True, count=n, mode=args.mode, source=source)