drydock-cli 3.0.49__tar.gz → 3.0.51__tar.gz

{drydock_cli-3.0.49/drydock_cli.egg-info → drydock_cli-3.0.51}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.49
+Version: 3.0.51
 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.51/drydock/gittools.py

@@ -0,0 +1,96 @@
+"""Dedicated Version Control helpers — first-class git for the agent.
+
+Git works through the generic Bash tool, but purpose-built git_* tools give the
+model concise, structured, TRUNCATED output (a raw `git diff` can blow the
+context window) and a safe commit path, without it having to remember exact git
+invocations. Read ops (status/diff/log) are side-effect-free; commit is local
+and reversible (push stays gated through Bash's approval modal).
+
+All logic original to Drydock.
+"""
+from __future__ import annotations
+
+import subprocess
+
+
+class GitError(RuntimeError):
+    """A git operation failed (not a repo, git missing, or a command error)."""
+
+
+def _run_git(args: list[str], cwd: str, timeout: float = 30.0) -> str:
+    """Run `git <args>` in cwd, returning stdout. Raises GitError on failure."""
+    try:
+        p = subprocess.run(
+            ["git", *args], cwd=cwd, capture_output=True, text=True,
+            timeout=timeout,
+        )
+    except FileNotFoundError as e:
+        raise GitError("git is not installed or not on PATH") from e
+    except subprocess.TimeoutExpired as e:
+        raise GitError(f"git {args[0]} timed out after {timeout:.0f}s") from e
+    if p.returncode != 0:
+        err = (p.stderr or p.stdout or "").strip()
+        if "not a git repository" in err.lower():
+            raise GitError(f"not a git repository: {cwd}")
+        raise GitError(err or f"git {args[0]} failed (exit {p.returncode})")
+    return p.stdout
+
+
+def _truncate(text: str, max_chars: int, *, tail: bool = False) -> str:
+    if len(text) <= max_chars:
+        return text
+    note = f"\n[... {len(text) - max_chars} chars truncated ...]\n"
+    return (note + text[-max_chars:]) if tail else (text[:max_chars] + note)
+
+
+def status(cwd: str) -> str:
+    """Branch + concise porcelain status of the working tree."""
+    branch = _run_git(["rev-parse", "--abbrev-ref", "HEAD"], cwd).strip()
+    porcelain = _run_git(["status", "--porcelain=v1", "--branch"], cwd).strip()
+    if len(porcelain.splitlines()) <= 1:  # only the "## branch" header line
+        return f"On branch {branch}. Working tree clean."
+    return f"On branch {branch}:\n{_truncate(porcelain, 4000)}"
+
+
+def diff(cwd: str, path: str | None = None, *, staged: bool = False,
+         max_chars: int = 8000) -> str:
+    """Working-tree (or --staged) diff, optionally scoped to a path. Truncated."""
+    args = ["diff"]
+    if staged:
+        args.append("--cached")
+    if path:
+        args += ["--", path]
+    out = _run_git(args, cwd)
+    if not out.strip():
+        scope = " (staged)" if staged else ""
+        return f"No{scope} changes" + (f" in {path}" if path else "") + "."
+    # Lead with a --stat summary so the model sees the shape even when truncated.
+    stat_args = ["diff", "--stat"] + (["--cached"] if staged else [])
+    if path:
+        stat_args += ["--", path]
+    stat = _run_git(stat_args, cwd).strip()
+    return f"{stat}\n\n{_truncate(out, max_chars)}"
+
+
+def log(cwd: str, n: int = 10) -> str:
+    """The last n commits, one line each."""
+    n = max(1, min(n, 50))
+    out = _run_git(["log", f"-{n}", "--oneline", "--decorate"], cwd).strip()
+    return out or "No commits yet."
+
+
+def commit(cwd: str, message: str, *, add_all: bool = True) -> str:
+    """Stage (all, by default) and commit. Local + reversible (git reset undoes
+    it). Refuses an empty message. Does NOT push."""
+    message = (message or "").strip()
+    if not message:
+        raise GitError("a commit needs a non-empty message")
+    if add_all:
+        _run_git(["add", "-A"], cwd)
+    # Nothing staged → say so instead of erroring opaquely.
+    staged = _run_git(["diff", "--cached", "--name-only"], cwd).strip()
+    if not staged:
+        return "Nothing to commit — the working tree has no staged changes."
+    out = _run_git(["commit", "-m", message], cwd)
+    head = _run_git(["rev-parse", "--short", "HEAD"], cwd).strip()
+    return f"Committed {head}:\n{out.strip()}"

{drydock_cli-3.0.49 → drydock_cli-3.0.51}/drydock/tools/__init__.py

@@ -161,6 +161,90 @@ SCHEMAS = [
             "required": ["prompt"],
         },
     },
+    {
+        "name": "GitStatus",
+        "description": (
+            "Show the current branch and a concise list of changed/staged/"
+            "untracked files (git status). Use it to understand the working tree "
+            "before editing or committing."
+        ),
+        "input_schema": {"type": "object", "properties": {}},
+    },
+    {
+        "name": "GitDiff",
+        "description": (
+            "Show the diff of changes (git diff), with a --stat summary first and "
+            "the body truncated to fit context. Set staged=true for staged "
+            "changes; pass a path to scope it to one file/dir."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string", "description": "Optional file/dir to scope the diff."},
+                "staged": {"type": "boolean", "description": "Diff staged changes instead of the working tree."},
+            },
+        },
+    },
+    {
+        "name": "GitLog",
+        "description": "Show the last n commits, one line each (git log --oneline).",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "n": {"type": "integer", "description": "How many commits (default 10)."},
+            },
+        },
+    },
+    {
+        "name": "GitCommit",
+        "description": (
+            "Stage all changes and commit with a message (git add -A && git "
+            "commit). Local and reversible; does NOT push. Use it to package a "
+            "completed, verified change. Write a clear, specific message."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "message": {"type": "string", "description": "The commit message."},
+                "add_all": {"type": "boolean", "description": "Stage all changes first (default true)."},
+            },
+            "required": ["message"],
+        },
+    },
+    {
+        "name": "WebSearch",
+        "description": (
+            "Search the internet and get back the top results (title, URL, "
+            "snippet). Use it for current events, docs, library/API details, "
+            "error messages, or anything you're unsure about or that may have "
+            "changed since training. Follow up with WebFetch to read a result in "
+            "full. Returns a clean message if the machine is offline."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "query": {"type": "string", "description": "The search query."},
+                "k": {"type": "integer", "description": "Max results (default 5)."},
+            },
+            "required": ["query"],
+        },
+    },
+    {
+        "name": "WebFetch",
+        "description": (
+            "Fetch a web page (or any URL) and return its readable text content, "
+            "HTML stripped. Use it to read a page found via WebSearch or a URL the "
+            "user gave you. Returns a clean message if the machine is offline."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "url": {"type": "string", "description": "The URL to fetch."},
+                "max_chars": {"type": "integer", "description": "Max chars to return (default 6000)."},
+            },
+            "required": ["url"],
+        },
+    },
     {
         "name": "Knowledge",
         "description": (
@@ -735,6 +819,90 @@ def tool_task(params: dict, config: dict) -> str:
     return f"[sub-agent finished {steps} step(s) with no summary]"
 
 
+def _git_cwd(config: dict) -> str:
+    return config.get("cwd") or os.getcwd()
+
+
+def tool_gitstatus(params: dict, config: dict) -> str:
+    from drydock import gittools
+    try:
+        return gittools.status(_git_cwd(config))
+    except gittools.GitError as e:
+        return f"git status failed: {e}"
+
+
+def tool_gitdiff(params: dict, config: dict) -> str:
+    from drydock import gittools
+    try:
+        return gittools.diff(
+            _git_cwd(config),
+            path=(params.get("path") or None),
+            staged=bool(params.get("staged")),
+        )
+    except gittools.GitError as e:
+        return f"git diff failed: {e}"
+
+
+def tool_gitlog(params: dict, config: dict) -> str:
+    from drydock import gittools
+    try:
+        n = int(params.get("n") or 10)
+    except (TypeError, ValueError):
+        n = 10
+    try:
+        return gittools.log(_git_cwd(config), n=n)
+    except gittools.GitError as e:
+        return f"git log failed: {e}"
+
+
+def tool_gitcommit(params: dict, config: dict) -> str:
+    from drydock import gittools
+    try:
+        return gittools.commit(
+            _git_cwd(config),
+            params.get("message") or "",
+            add_all=params.get("add_all", True) is not False,
+        )
+    except gittools.GitError as e:
+        return f"git commit failed: {e}"
+
+
+def tool_websearch(params: dict, config: dict) -> str:
+    """Search the internet (DuckDuckGo). Read-only; clean message when offline."""
+    from drydock import web
+
+    query = (params.get("query") or "").strip()
+    if not query:
+        return "Error: `WebSearch` needs a `query`."
+    try:
+        k = int(params.get("k") or 5)
+    except (TypeError, ValueError):
+        k = 5
+    try:
+        results = web.search(query, k=max(1, min(k, 10)))
+    except web.WebError as e:
+        return f"Web search unavailable: {e}. You appear to be offline — answer from your own knowledge."
+    return web.format_search(query, results)
+
+
+def tool_webfetch(params: dict, config: dict) -> str:
+    """Fetch a URL and return readable text. Read-only; clean message offline."""
+    from drydock import web
+
+    url = (params.get("url") or "").strip()
+    if not url:
+        return "Error: `WebFetch` needs a `url`."
+    try:
+        mc = int(params.get("max_chars") or 6000)
+    except (TypeError, ValueError):
+        mc = 6000
+    try:
+        text = web.fetch(url, max_chars=max(500, min(mc, 30000)))
+    except web.WebError as e:
+        return f"Could not fetch the page: {e}."
+    return text or f"(no readable text extracted from {url})"
+
+
 def tool_knowledge(params: dict, config: dict) -> str:
     """Query the project's GraphRAG knowledge base (built with /graphrag build).
     Read-only; returns the most relevant passages plus related graph entities.
@@ -773,6 +941,12 @@ _TOOLS = [
     ("todo", tool_todo, False),
     ("task", tool_task, True),
     ("Knowledge", tool_knowledge, True),
+    ("WebSearch", tool_websearch, True),
+    ("WebFetch", tool_webfetch, True),
+    ("GitStatus", tool_gitstatus, True),
+    ("GitDiff", tool_gitdiff, True),
+    ("GitLog", tool_gitlog, True),
+    ("GitCommit", tool_gitcommit, False),
 ]
 
 def register_all():
@@ -782,9 +956,16 @@ def register_all():
             "Read": tool_read, "Write": tool_write, "Edit": tool_edit,
             "Bash": tool_bash, "Glob": tool_glob, "Grep": tool_grep,
             "todo": tool_todo, "task": tool_task, "Knowledge": tool_knowledge,
+            "WebSearch": tool_websearch, "WebFetch": tool_webfetch,
+            "GitStatus": tool_gitstatus, "GitDiff": tool_gitdiff,
+            "GitLog": tool_gitlog, "GitCommit": tool_gitcommit,
         }[name]
-        # task + Knowledge are read-only w.r.t. the parent's files.
-        read_only = name in ("Read", "Glob", "Grep", "task", "Knowledge")
+        # Read-only w.r.t. the parent's files (GitStatus/Diff/Log inspect only;
+        # GitCommit writes a local, reversible commit).
+        read_only = name in (
+            "Read", "Glob", "Grep", "task", "Knowledge", "WebSearch", "WebFetch",
+            "GitStatus", "GitDiff", "GitLog",
+        )
         register(ToolDef(name=name, schema=schema, func=func, read_only=read_only))
 
 register_all()

drydock_cli-3.0.51/drydock/web.py

@@ -0,0 +1,98 @@
+"""Internet access — web search + page fetch, stdlib only (no deps, no API key).
+
+Search goes through DuckDuckGo's HTML endpoint (a form POST; the GET form is
+bot-challenged). Fetch pulls a page and reduces it to readable text. Both are
+best-effort and degrade cleanly when offline — drydock targets local LLMs that
+may run air-gapped, so a network failure returns a plain message, never raises.
+
+All logic original to Drydock.
+"""
+from __future__ import annotations
+
+import html
+import re
+import urllib.error
+import urllib.parse
+import urllib.request
+
+_UA = "Mozilla/5.0 (X11; Linux x86_64; rv:124.0) Gecko/20100101 Firefox/124.0"
+_DDG = "https://html.duckduckgo.com/html/"
+
+_RE_RESULT = re.compile(r'result__a"[^>]*href="([^"]+)".*?>(.*?)</a>', re.S)
+_RE_SNIPPET = re.compile(r'result__snippet"[^>]*>(.*?)</a>', re.S)
+_RE_TAG = re.compile(r"<[^>]+>")
+_RE_SCRIPT = re.compile(r"<(script|style|noscript|svg)\b.*?</\1>", re.S | re.I)
+_RE_WS = re.compile(r"[ \t]+")
+_RE_BLANKS = re.compile(r"\n\s*\n\s*\n+")
+
+
+def _strip_html(s: str) -> str:
+    return html.unescape(_RE_TAG.sub("", s)).strip()
+
+
+class WebError(RuntimeError):
+    """Network/HTTP failure reaching the internet (carries a user-facing msg)."""
+
+
+def search(query: str, k: int = 5, *, timeout: float = 12.0) -> list[dict]:
+    """Return up to k web results: [{title, url, snippet}]. Raises WebError on a
+    network failure so the caller can show a clean offline message."""
+    data = urllib.parse.urlencode({"q": query}).encode()
+    req = urllib.request.Request(_DDG, data=data, headers={"User-Agent": _UA})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:  # noqa: S310 (trusted)
+            body = r.read().decode("utf-8", "ignore")
+    except (urllib.error.URLError, OSError) as e:
+        raise WebError(f"could not reach the internet ({e})") from e
+
+    links = _RE_RESULT.findall(body)
+    snippets = _RE_SNIPPET.findall(body)
+    out: list[dict] = []
+    for (url, title), snip in zip(links, snippets + [""] * len(links)):
+        url = html.unescape(url)
+        if url.startswith("//"):
+            url = "https:" + url
+        # DDG sometimes wraps the target in a redirect with ?uddg=<real-url>.
+        m = re.search(r"[?&]uddg=([^&]+)", url)
+        if m:
+            url = urllib.parse.unquote(m.group(1))
+        out.append({"title": _strip_html(title), "url": url, "snippet": _strip_html(snip)})
+        if len(out) >= k:
+            break
+    return out
+
+
+def fetch(url: str, *, max_chars: int = 6000, timeout: float = 12.0) -> str:
+    """Fetch a URL and return its readable text (HTML stripped). Raises WebError
+    on a network/HTTP failure."""
+    if not url.startswith(("http://", "https://")):
+        url = "https://" + url
+    req = urllib.request.Request(url, headers={"User-Agent": _UA})
+    try:
+        with urllib.request.urlopen(req, timeout=timeout) as r:  # noqa: S310 (user-supplied URL)
+            ctype = r.headers.get("Content-Type", "")
+            raw = r.read(4_000_000)  # cap the download
+    except (urllib.error.URLError, OSError) as e:
+        raise WebError(f"could not fetch {url} ({e})") from e
+
+    text = raw.decode("utf-8", "ignore")
+    if "html" in ctype.lower() or "<html" in text[:2000].lower():
+        text = _RE_SCRIPT.sub(" ", text)
+        text = _RE_TAG.sub(" ", text)
+        text = html.unescape(text)
+    text = _RE_WS.sub(" ", text)
+    text = _RE_BLANKS.sub("\n\n", "\n".join(ln.strip() for ln in text.splitlines()))
+    text = text.strip()
+    if len(text) > max_chars:
+        text = text[:max_chars] + f"\n[... truncated, {len(text) - max_chars} more chars ...]"
+    return text
+
+
+def format_search(query: str, results: list[dict]) -> str:
+    if not results:
+        return f"No web results for {query!r}."
+    parts = [f"Web results for {query!r}:"]
+    for i, r in enumerate(results, 1):
+        parts.append(f"\n[{i}] {r['title']}\n    {r['url']}\n    {r['snippet']}")
+    parts.append("\nTo read one in full, use WebFetch with its URL.")
+    return "\n".join(parts)

{drydock_cli-3.0.49 → drydock_cli-3.0.51/drydock_cli.egg-info}/PKG-INFO

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

@@ -10,12 +10,14 @@ drydock/cli.py
 drydock/compaction.py
 drydock/config.py
 drydock/detect.py
+drydock/gittools.py
 drydock/graphrag.py
 drydock/guards.py
 drydock/loop_detect.py
 drydock/providers.py
 drydock/tool_registry.py
 drydock/tuning.py
+drydock/web.py
 drydock/tools/__init__.py
 drydock/tui/__init__.py
 drydock/tui/app.py
@@ -43,6 +45,7 @@ tests/test_detect.py
 tests/test_empty_response.py
 tests/test_failure_loop.py
 tests/test_first_run_setup.py
+tests/test_gittools.py
 tests/test_graphrag.py
 tests/test_guards_and_tools.py
 tests/test_hallucinated_tools.py
@@ -60,4 +63,5 @@ tests/test_tool_arg_parsing.py
 tests/test_tools_undo.py
 tests/test_tui.py
 tests/test_tuning.py
-tests/test_vision_input.py
+tests/test_vision_input.py
+tests/test_web_tools.py

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

drydock_cli-3.0.51/tests/test_gittools.py

@@ -0,0 +1,78 @@
+"""Dedicated Version Control tools (drydock/gittools.py): structured, truncated
+git for the agent. Tests run in isolated temp repos."""
+from __future__ import annotations
+
+import subprocess
+
+import pytest
+
+from drydock import gittools
+from drydock.tools import (
+    tool_gitstatus, tool_gitdiff, tool_gitlog, tool_gitcommit,
+)
+
+
+def _git(args, cwd):
+    subprocess.run(["git", *args], cwd=cwd, check=True, capture_output=True, text=True)
+
+
+@pytest.fixture
+def repo(tmp_path):
+    _git(["init", "-q"], tmp_path)
+    _git(["config", "user.email", "t@t.com"], tmp_path)
+    _git(["config", "user.name", "T"], tmp_path)
+    (tmp_path / "a.txt").write_text("hello\n")
+    _git(["add", "-A"], tmp_path)
+    _git(["commit", "-qm", "initial"], tmp_path)
+    return tmp_path
+
+
+def test_status_clean_then_dirty(repo):
+    cfg = {"cwd": str(repo)}
+    assert "clean" in tool_gitstatus({}, cfg).lower()
+    (repo / "a.txt").write_text("hello\nworld\n")
+    out = tool_gitstatus({}, cfg)
+    assert "a.txt" in out and "clean" not in out.lower()
+
+
+def test_diff_shows_stat_and_body(repo):
+    (repo / "a.txt").write_text("hello\nchanged\n")
+    out = tool_gitdiff({}, {"cwd": str(repo)})
+    assert "a.txt" in out and "changed" in out and "insertion" in out
+
+
+def test_diff_no_changes(repo):
+    assert "No changes" in tool_gitdiff({}, {"cwd": str(repo)})
+
+
+def test_log_lists_commits(repo):
+    out = tool_gitlog({"n": 5}, {"cwd": str(repo)})
+    assert "initial" in out
+
+
+def test_commit_stages_and_commits(repo):
+    (repo / "b.txt").write_text("new file\n")
+    out = tool_gitcommit({"message": "add b"}, {"cwd": str(repo)})
+    assert "Committed" in out
+    assert "add b" in tool_gitlog({}, {"cwd": str(repo)})
+
+
+def test_commit_empty_message_refused(repo):
+    (repo / "b.txt").write_text("x")
+    assert "non-empty message" in tool_gitcommit({"message": "  "}, {"cwd": str(repo)})
+
+
+def test_commit_nothing_to_commit(repo):
+    assert "Nothing to commit" in tool_gitcommit({"message": "noop"}, {"cwd": str(repo)})
+
+
+def test_not_a_repo_is_graceful(tmp_path):
+    out = tool_gitstatus({}, {"cwd": str(tmp_path)})
+    assert "not a git repository" in out.lower()
+
+
+def test_diff_truncates_large_body(repo):
+    # modify a TRACKED file so it appears in the working-tree diff
+    (repo / "a.txt").write_text("\n".join(f"line {i}" for i in range(5000)))
+    out = gittools.diff(str(repo), max_chars=1000)
+    assert "truncated" in out and len(out) < 4000

drydock_cli-3.0.51/tests/test_web_tools.py

@@ -0,0 +1,72 @@
+"""Internet access: WebSearch + WebFetch tools (drydock/web.py). Network is
+mocked so tests are deterministic and run offline; the offline path is tested
+explicitly (drydock targets local LLMs that may be air-gapped — must degrade,
+never raise)."""
+from __future__ import annotations
+
+
+from drydock import web
+from drydock.tools import tool_websearch, tool_webfetch
+
+
+def test_websearch_formats_results(monkeypatch):
+    monkeypatch.setattr(web, "search", lambda q, k=5, **kw: [
+        {"title": "Python 3.13", "url": "https://docs.python.org/3/whatsnew/3.13.html",
+         "snippet": "new features"},
+    ])
+    out = tool_websearch({"query": "python 3.13 features"}, {})
+    assert "Python 3.13" in out and "docs.python.org" in out and "WebFetch" in out
+
+
+def test_websearch_offline_is_graceful(monkeypatch):
+    def boom(*a, **k):
+        raise web.WebError("could not reach the internet (offline)")
+    monkeypatch.setattr(web, "search", boom)
+    out = tool_websearch({"query": "anything"}, {})
+    assert "unavailable" in out.lower() and "offline" in out.lower()
+
+
+def test_websearch_needs_query():
+    assert "needs a `query`" in tool_websearch({}, {})
+
+
+def test_webfetch_returns_text(monkeypatch):
+    monkeypatch.setattr(web, "fetch", lambda url, **kw: "Readable page text here.")
+    out = tool_webfetch({"url": "example.com"}, {})
+    assert out == "Readable page text here."
+
+
+def test_webfetch_offline_is_graceful(monkeypatch):
+    def boom(*a, **k):
+        raise web.WebError("could not fetch (offline)")
+    monkeypatch.setattr(web, "fetch", boom)
+    out = tool_webfetch({"url": "https://x.com"}, {})
+    assert "could not fetch" in out.lower()
+
+
+def test_webfetch_needs_url():
+    assert "needs a `url`" in tool_webfetch({}, {})
+
+
+def test_strip_html_and_parsing_helpers():
+    # The HTML→text reducer drops tags + unescapes entities.
+    assert web._strip_html("<b>Hello &amp; bye</b>") == "Hello & bye"
+
+
+def test_search_parses_ddg_html(monkeypatch):
+    sample = (
+        '<a class="result__a" href="//duckduckgo.com/l/?uddg=https%3A%2F%2Fexample.com%2Fa">'
+        'Example A</a>'
+        '<a class="result__snippet" href="x">snippet A text</a>'
+    )
+
+    class _Resp:
+        def __enter__(self): return self
+        def __exit__(self, *a): return False
+        def read(self): return sample.encode()
+
+    monkeypatch.setattr(web.urllib.request, "urlopen", lambda *a, **k: _Resp())
+    res = web.search("q", k=5)
+    assert res and res[0]["title"] == "Example A"
+    assert res[0]["url"] == "https://example.com/a"   # uddg redirect unwrapped
+    assert res[0]["snippet"] == "snippet A text"