drydock-cli 3.0.112__tar.gz → 3.0.114__tar.gz

{drydock_cli-3.0.112/drydock_cli.egg-info → drydock_cli-3.0.114}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: drydock-cli
-Version: 3.0.112
+Version: 3.0.114
 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.112 → drydock_cli-3.0.114}/drydock/graphrag.py

@@ -134,25 +134,28 @@ def _ingest_files(paths, cwd, chunks, entity_chunks, edges, skip_sources):
     cleaned = [_unquote(p) for p in paths]
     for fp in _iter_text_files([str(Path(cwd) / p) if not os.path.isabs(p) else p
                                 for p in cleaned]):
-        rel = os.path.relpath(str(fp), cwd)
-        if rel in skip_sources:
-            continue
-        if fp.suffix.lower() in extract.EXTRACTABLE_EXT:
-            text = extract.extract_document(fp)  # PDF/Word → text (or None)
-            if not text:
-                continue  # unreadable / no PDF backend — skip cleanly
-        else:
-            try:
-                text = fp.read_text("utf-8", "ignore")
-            except OSError:
+        # Per-file isolation: ONE unreadable/odd file (a locked Word doc, a weird
+        # encoding, a PDF backend quirk) must never crash a whole-folder build —
+        # skip it and keep indexing the rest.
+        try:
+            rel = os.path.relpath(str(fp), cwd)
+            if rel in skip_sources:
                 continue
-        if not text.strip():
+            if fp.suffix.lower() in extract.EXTRACTABLE_EXT:
+                text = extract.extract_document(fp)  # PDF/Word → text (or None)
+            else:
+                text = fp.read_text("utf-8", "ignore")
+            if not text or not text.strip():
+                continue  # unreadable / empty — skip cleanly
+            # Build this file's chunks locally; commit only if it ALL succeeds so a
+            # mid-file failure leaves no partial state and isn't miscounted.
+            local = [(body, extract_entities(body)) for body in _chunk_text(text)]
+        except Exception:  # noqa: BLE001 — isolate a bad file, never abort the build
             continue
         added += 1
         skip_sources.add(rel)  # don't double-ingest the same file in one call
-        for body in _chunk_text(text):
+        for body, ents in local:
             cid = len(chunks)
-            ents = extract_entities(body)
             chunks.append({"id": cid, "source": rel, "text": body, "entities": ents})
             for e in ents:
                 entity_chunks[e].add(cid)

{drydock_cli-3.0.112 → drydock_cli-3.0.114}/drydock/tools/__init__.py

@@ -244,6 +244,22 @@ SCHEMAS = [
             "required": ["path"],
         },
     },
+    {
+        "name": "Screenshot",
+        "description": "CAPTURE the current screen and SEE it with your vision — use "
+                       "when the user asks you to look at their screen, review what's "
+                       "displayed, debug a GUI, or read something shown on screen. Takes "
+                       "the screenshot and shows it to you directly (no need to call "
+                       "ViewImage after). Works on Windows (PowerShell), macOS, and "
+                       "Linux with a display. Optionally pass `path` to also save the PNG.",
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {"type": "string",
+                         "description": "Optional file to save the PNG to. Omit to use a temp file."},
+            },
+        },
+    },
     {
         "name": "Write",
         "description": "Write content to a file, creating parent directories as needed.",
@@ -607,6 +623,34 @@ SCHEMAS = [
             "required": ["query"],
         },
     },
+    {
+        "name": "BuildKnowledge",
+        "description": (
+            "BUILD or extend the user's GraphRAG knowledge base FROM THEIR documents "
+            "or code. Call this YOURSELF when the user asks you to index / ingest / "
+            "'make a knowledge base from' a folder or file (e.g. 'create a knowledge "
+            "base from my Documents'). Give `path` (a file or directory). mode 'build' "
+            "= (re)build from scratch; 'add' = merge into an existing base. When it "
+            "succeeds you can search it with the Knowledge tool. Do NOT tell the user "
+            "to type a '/graphrag' slash command — actually do it with this tool."
+        ),
+        "input_schema": {
+            "type": "object",
+            "properties": {
+                "path": {
+                    "type": "string",
+                    "description": "File or directory to index. A normal path — on "
+                                   "Windows e.g. C:\\Users\\me\\Documents (quotes optional).",
+                },
+                "mode": {
+                    "type": "string",
+                    "description": "'build' (rebuild from scratch, default) or 'add' "
+                                   "(merge into the existing base).",
+                },
+            },
+            "required": ["path"],
+        },
+    },
 ]
 
 # ── Tool implementations ──────────────────────────────────────────────────
@@ -683,6 +727,74 @@ def tool_viewimage(params: dict, config: dict) -> str:
             "to you. Describe it, read any text in it, or use it to answer the task.")
 
 
+def _capture_screen(out: str) -> str | None:
+    """Grab the whole (virtual) screen to PNG `out`. Returns an error string, or
+    None on success. Per-OS: Windows uses PowerShell + System.Drawing; macOS uses
+    screencapture; Linux tries the common grabbers in turn."""
+    import shutil
+    import subprocess
+    try:
+        if _IS_WINDOWS:
+            ps = (
+                "Add-Type -AssemblyName System.Windows.Forms,System.Drawing; "
+                "$s=[System.Windows.Forms.SystemInformation]::VirtualScreen; "
+                "$b=New-Object System.Drawing.Bitmap $s.Width,$s.Height; "
+                "$g=[System.Drawing.Graphics]::FromImage($b); "
+                "$g.CopyFromScreen($s.Left,$s.Top,0,0,$b.Size); "
+                f"$b.Save('{out}',[System.Drawing.Imaging.ImageFormat]::Png); "
+                "$g.Dispose(); $b.Dispose()"
+            )
+            exe = shutil.which("pwsh") or shutil.which("powershell") or "powershell"
+            subprocess.run([exe, "-NoProfile", "-NonInteractive", "-Command", ps],
+                           capture_output=True, timeout=30)
+        elif sys.platform == "darwin":
+            subprocess.run(["screencapture", "-x", out], capture_output=True, timeout=30)
+        else:  # Linux/BSD — try grabbers in order of ubiquity (X11 + wayland)
+            grabbers = (["scrot", "-o", out], ["import", "-window", "root", out],
+                        ["gnome-screenshot", "-f", out], ["grim", out],
+                        ["spectacle", "-b", "-n", "-o", out], ["maim", out])
+            tried = [g[0] for g in grabbers if shutil.which(g[0])]
+            if not tried:
+                return ("no screenshot tool found. Install one of: scrot, imagemagick "
+                        "(import), gnome-screenshot, grim (wayland), spectacle, maim.")
+            for g in grabbers:
+                if shutil.which(g[0]):
+                    subprocess.run(g, capture_output=True, timeout=30)
+                    if os.path.isfile(out) and os.path.getsize(out):
+                        break
+    except subprocess.TimeoutExpired:
+        return "screen capture timed out (30s)."
+    except Exception as e:  # noqa: BLE001 — report, never crash the loop
+        return f"screen capture failed: {e}"
+    return None
+
+
+def tool_screenshot(params: dict, config: dict) -> str:
+    """Capture the screen to a PNG and make it visible to the vision model — the
+    returned absolute path is auto-attached by the API boundary, same as ViewImage."""
+    import tempfile
+
+    raw = _as_str_arg(params.get("path")).strip()
+    out = os.path.abspath(_resolve_path(raw, config) if raw
+                          else os.path.join(tempfile.gettempdir(), "drydock_screenshot.png"))
+    try:
+        if os.path.dirname(out):
+            os.makedirs(os.path.dirname(out), exist_ok=True)
+    except OSError:
+        pass
+    err = _capture_screen(out)
+    if err:
+        return (f"Error: {err} (On a headless server there is no display to capture.)")
+    if not os.path.isfile(out) or not os.path.getsize(out):
+        return "Error: screen capture produced no image (no display, or the grabber failed)."
+    size = os.path.getsize(out)
+    if size > _MAX_VIEW_IMAGE_BYTES:
+        return (f"Captured the screen to {out} but it is {size // 1_000_000}MB — too "
+                "large to view (limit 20MB). The file is saved; open it manually.")
+    return (f"Captured the screen to {out} (PNG, {size // 1024 or 1}KB) — it is now "
+            "visible to you. Describe what's on screen or use it to answer the task.")
+
+
 def tool_read(params: dict, config: dict) -> str:
     fp = _resolve_path(_as_str_arg(params.get("file_path")), config)
     # Reading an image as text yields binary garbage — point at the vision tool.
@@ -1741,10 +1853,39 @@ def tool_knowledge(params: dict, config: dict) -> str:
     return graphrag.format_results(result, query)
 
 
+def tool_build_knowledge(params: dict, config: dict) -> str:
+    """Build/extend the GraphRAG knowledge base from a file or directory of docs —
+    the model-callable equivalent of `/graphrag build|add`, so the agent can do it
+    itself when asked instead of telling the user to run a slash command."""
+    from drydock import graphrag
+
+    path = _as_str_arg(params.get("path")).strip()
+    if not path:
+        return ("Error: `BuildKnowledge` needs a `path` — a file or directory of "
+                "documents/code to index.")
+    mode = (_as_str_arg(params.get("mode")) or "build").strip().lower()
+    if mode not in ("build", "add"):
+        mode = "build"
+    cwd = config.get("cwd") or os.getcwd()
+    store = config.get("graphrag_store") or graphrag.default_store_path(cwd)
+    try:
+        fn = graphrag.build_index if mode == "build" else graphrag.add_to_index
+        stats = fn([path], store, cwd=cwd)
+    except Exception as e:  # noqa: BLE001 — report, never crash the agent loop
+        return f"Error building the knowledge base from {path}: {e}"
+    if not stats.get("chunks"):
+        return (f"No indexable text found under {path}. Nothing was added. (Supported: "
+                "text/code files, .docx, .pdf, .md, etc. Check the path is correct.)")
+    verb = "Built" if mode == "build" else "Updated"
+    return (f"{verb} the knowledge base: {stats['files']} files, {stats['chunks']} "
+            f"chunks, {stats['entities']} entities. Search it with the Knowledge tool.")
+
+
 # ── Register all tools ────────────────────────────────────────────────────
 
 _TOOLS = [
     ("Read", tool_read, True),
+    ("Screenshot", tool_screenshot, True),
     ("Write", tool_write, False),
     ("Edit", tool_edit, False),
     ("Bash", tool_bash, False),
@@ -1754,6 +1895,7 @@ _TOOLS = [
     ("task", tool_task, True),
     ("Dispatch", tool_dispatch, True),
     ("Knowledge", tool_knowledge, True),
+    ("BuildKnowledge", tool_build_knowledge, False),
     ("GraphQuery", tool_graphquery, True),
     ("GraphAdd", tool_graphadd, False),
     ("StigRules", tool_stigrules, True),
@@ -1772,10 +1914,12 @@ def register_all():
         name = schema["name"]
         func = {
             "Read": tool_read, "ViewImage": tool_viewimage,
+            "Screenshot": tool_screenshot,
             "Write": tool_write, "Edit": tool_edit,
             "Bash": tool_bash, "Glob": tool_glob, "Grep": tool_grep,
             "todo": tool_todo, "task": tool_task, "Dispatch": tool_dispatch,
             "Consult": tool_consult, "Knowledge": tool_knowledge,
+            "BuildKnowledge": tool_build_knowledge,
             "GraphQuery": tool_graphquery, "GraphAdd": tool_graphadd,
             "StigRules": tool_stigrules, "StigRule": tool_stigrule, "StigSet": tool_stigset,
             "WebSearch": tool_websearch, "WebFetch": tool_webfetch,
@@ -1785,7 +1929,7 @@ def register_all():
         # Read-only w.r.t. the parent's files (GitStatus/Diff/Log inspect only;
         # GitCommit + GraphAdd write).
         read_only = name in (
-            "Read", "ViewImage", "Glob", "Grep", "task", "Dispatch", "Consult",
+            "Read", "ViewImage", "Screenshot", "Glob", "Grep", "task", "Dispatch", "Consult",
             "Knowledge", "GraphQuery", "StigRules", "StigRule",
             "WebSearch", "WebFetch", "GitStatus", "GitDiff", "GitLog",
         )

{drydock_cli-3.0.112 → drydock_cli-3.0.114/drydock_cli.egg-info}/PKG-INFO

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

@@ -97,6 +97,7 @@ tests/test_rmf.py
 tests/test_rmf_graph.py
 tests/test_rmf_stig_graph.py
 tests/test_runaway_repetition.py
+tests/test_screenshot.py
 tests/test_server_probe.py
 tests/test_skills.py
 tests/test_stall_retry.py

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

{drydock_cli-3.0.112 → drydock_cli-3.0.114}/tests/test_graphrag_quoted_path.py

@@ -41,3 +41,36 @@ def test_unquote_helper():
     assert graphrag._unquote("/plain/path") == "/plain/path"
     assert graphrag._unquote('  "spaced"  ') == "spaced"
     assert graphrag._unquote('"') == '"'  # lone quote unchanged
+
+
+def test_one_bad_file_does_not_abort_build():
+    """A single file that raises mid-processing must be skipped, not crash the
+    whole folder build (the Windows 'NoneType.strip' report)."""
+    from unittest import mock
+    src, store = _make_docs()
+    open(os.path.join(src, "boom.txt"), "w").write("EXPLODE here")
+    real = graphrag.extract_entities
+
+    def boom(text):
+        if "EXPLODE" in text:
+            raise AttributeError("'NoneType' object has no attribute 'strip'")
+        return real(text)
+
+    with mock.patch.object(graphrag, "extract_entities", boom):
+        stats = graphrag.build_index([src], store)
+    assert stats["files"] == 2  # the 2 good files indexed, boom.txt skipped (not counted)
+
+
+def test_build_knowledge_tool_builds_and_reports():
+    from drydock import tools
+    src, store = _make_docs()
+    out = tools.tool_build_knowledge({"path": f'"{src}"', "mode": "build"},
+                                     {"cwd": os.getcwd(), "graphrag_store": store})
+    assert "Built the knowledge base" in out and "2 files" in out
+
+
+def test_build_knowledge_available_to_gemma():
+    from drydock import tool_registry
+    from drydock.tuning import filter_tool_schemas
+    names = [s["name"] for s in filter_tool_schemas(tool_registry.schemas(), "gemma4")]
+    assert "BuildKnowledge" in names

drydock_cli-3.0.114/tests/test_screenshot.py

@@ -0,0 +1,59 @@
+"""Screenshot tool: capture the screen to PNG and make it visible to the vision
+model (the returned path auto-attaches, same path as ViewImage). Cross-platform:
+PowerShell on Windows, screencapture on macOS, common grabbers on Linux."""
+from __future__ import annotations
+
+import os
+import tempfile
+from unittest import mock
+
+from drydock import tools, tool_registry
+from drydock.providers import detect_image_paths
+from drydock.tuning import filter_tool_schemas
+
+
+def test_registered_and_available_to_gemma():
+    names = [s["name"] for s in tool_registry.schemas()]
+    gnames = [s["name"] for s in filter_tool_schemas(tool_registry.schemas(), "gemma4")]
+    assert "Screenshot" in names and "Screenshot" in gnames
+
+
+def test_graceful_when_no_grabber(monkeypatch):
+    monkeypatch.setattr(tools, "_IS_WINDOWS", False)
+    monkeypatch.setattr("sys.platform", "linux")
+    monkeypatch.setattr("shutil.which", lambda _n: None)  # no grabbers installed
+    out = tools.tool_screenshot({}, {"cwd": os.getcwd()})
+    assert out.startswith("Error") and "screenshot tool" in out
+
+
+def test_success_returns_attachable_path():
+    png = tempfile.mktemp(suffix=".png")
+
+    def fake_cap(o):
+        open(o, "wb").write(b"\x89PNG\r\n\x1a\n" + b"\x00" * 200)
+        return None
+
+    with mock.patch.object(tools, "_capture_screen", fake_cap):
+        out = tools.tool_screenshot({"path": png}, {"cwd": os.getcwd()})
+    assert "visible to you" in out
+    assert detect_image_paths(out) == [os.path.abspath(png)]  # auto-attaches
+
+
+def test_windows_builds_powershell_capture():
+    calls = {}
+    with mock.patch.object(tools, "_IS_WINDOWS", True), \
+         mock.patch("shutil.which", side_effect=lambda n: r"C:\pwsh.exe" if n == "pwsh" else None), \
+         mock.patch("subprocess.run", side_effect=lambda a, **k: calls.setdefault("argv", a)):
+        assert tools._capture_screen(r"C:\shot.png") is None
+    argv = calls["argv"]
+    assert argv[0].endswith("pwsh.exe") and argv[1] == "-NoProfile"
+    assert "CopyFromScreen" in argv[-1] and "ImageFormat]::Png" in argv[-1]
+
+
+def test_macos_uses_screencapture(monkeypatch):
+    calls = {}
+    monkeypatch.setattr(tools, "_IS_WINDOWS", False)
+    monkeypatch.setattr("sys.platform", "darwin")
+    monkeypatch.setattr("subprocess.run", lambda a, **k: calls.setdefault("argv", a))
+    tools._capture_screen("/tmp/x.png")
+    assert calls["argv"][0] == "screencapture"