witan-code 0.2.0__py3-none-any.whl

witan_code/setup.py

@@ -0,0 +1,230 @@
+"""Witan-code's registration bundle, plus the omnigraph binary installer.
+
+Per-agent MCP/skill/hook installation itself lives in ``agent_config_kit``
+(``apply``/``apply_all``) — this module only builds witan-code's own
+``RegistrationBundle`` and keeps the omnigraph binary distribution logic.
+
+The bundle-building shape is copied from witan/witan/setup.py so the two
+Layer packages stay independent — no cross-package imports, matching
+OmnigraphClient's own docstring in graph.py. ``_OMNIGRAPH_VERSION`` here is
+kept in lockstep with witan's copy by the omnigraph-version customManager in
+renovate.json — a single Renovate PR bumps both.
+"""
+
+from __future__ import annotations
+
+import platform
+import re
+import subprocess
+import tarfile
+import tempfile
+import urllib.request
+from pathlib import Path
+
+from agent_config_kit import (
+    DeclarativeHook,
+    Hook,
+    HookEvent,
+    PluginRegistration,
+    RegistrationBundle,
+    SkillSource,
+    StdioServer,
+)
+
+_WITAN_CODE_ARGS = [
+    "--from",
+    "git+https://github.com/mitodl/agent-kit#subdirectory=mcp/servers/witan-code",
+    "witan-code",
+    "serve",
+]
+
+_OMNIGRAPH_VERSION = "0.8.1"
+_OMNIGRAPH_ASSETS: dict[tuple[str, str], str] = {
+    ("linux", "x86_64"): "omnigraph-linux-x86_64.tar.gz",
+    ("darwin", "arm64"): "omnigraph-macos-arm64.tar.gz",
+}
+_VERSION_RE = re.compile(r"\d+\.\d+\.\d+")
+
+
+def _installed_version(dest: Path) -> str | None:
+    """Return ``dest``'s reported version, or ``None`` if absent/unreadable.
+
+    A hung, corrupted, or non-executable binary must degrade to "unknown
+    version" (triggering a re-download) rather than crash `setup` —
+    ``subprocess.TimeoutExpired`` is a ``SubprocessError``, not an
+    ``OSError``, so both need catching, and a non-zero exit means the
+    output isn't trustworthy version text even if something printed.
+    """
+    if not dest.exists():
+        return None
+    try:
+        result = subprocess.run(
+            [str(dest), "--version"], capture_output=True, text=True, timeout=10
+        )
+    except (OSError, subprocess.SubprocessError):
+        return None
+    if result.returncode != 0:
+        return None
+    match = _VERSION_RE.search(result.stdout + result.stderr)
+    return match.group(0) if match else None
+
+
+def witan_code_bundle(
+    pkg_dir: Path, author: str, *, binary: str = "witan-code"
+) -> RegistrationBundle:
+    """Build witan-code's ``RegistrationBundle``: MCP server, skill, hooks.
+
+    Independent of ``witan``'s own bundle (``witan.setup.witan_bundle``) — a
+    witan-code-only install (no witan) still gets the skill, hooks, and Pi
+    extension via standalone ``witan-code setup``. When both packages are
+    installed together and witan-code is importable, ``witan setup`` also
+    folds this bundle in automatically (see ``witan.cli.setup_cmd``), so a
+    single ``witan setup`` covers both; running ``witan-code setup``
+    separately afterwards is harmless (each `apply()` call is an idempotent
+    read-merge-write) but not required in that case.
+
+    Parameters
+    ----------
+    binary: The command name hook entries invoke — ``"witan-code"`` for a
+        standalone install (this function's default), or ``"witan code"``
+        when ``witan.cli.setup_cmd`` folds this bundle into witan's own (the
+        hooks then only need `witan` — with witan-code bundled in via
+        ``--with`` — on PATH, not a separately installed `witan-code`).
+    """
+    skills_dir = pkg_dir / "skills"
+    skills = (
+        [
+            SkillSource(name=d.name, skill_md_path=d / "SKILL.md")
+            for d in sorted(skills_dir.iterdir())
+            if (d / "SKILL.md").exists()
+        ]
+        if skills_dir.is_dir()
+        else []
+    )
+
+    pi_ext_dir = pkg_dir / "extensions" / "pi"
+    # Bare CLI commands, no wrapper script — portable everywhere `binary`
+    # installs (Windows included, where bash/setsid don't exist), matching
+    # witan's own `witan inject-context`/`session-checkpoint` hooks. The
+    # prompt-path timeouts mirror witan's: a hung git or store read must
+    # degrade to no context/no compaction, never stall the agent.
+    hooks: list[Hook] = [
+        DeclarativeHook(
+            event=HookEvent.SESSION_START,
+            command=f"{binary} session-init",
+        ),
+        DeclarativeHook(
+            event=HookEvent.POST_TOOL_USE,
+            matcher="Edit|Write",
+            command=f"{binary} reindex-hook",
+        ),
+        DeclarativeHook(
+            event=HookEvent.USER_PROMPT_SUBMIT,
+            command=f"{binary} inject-context",
+            timeout_seconds=15,
+        ),
+        DeclarativeHook(
+            event=HookEvent.STOP,
+            command=f"{binary} checkpoint",
+            timeout_seconds=15,
+        ),
+    ]
+    if pi_ext_dir.is_dir():
+        hooks.extend(
+            PluginRegistration(entry_path=f)
+            for f in sorted(pi_ext_dir.iterdir())
+            if f.suffix == ".ts"
+        )
+
+    return RegistrationBundle(
+        mcp_servers={
+            "witan-code": StdioServer(
+                command="uvx", args=_WITAN_CODE_ARGS, env={"WITAN_AUTHOR": author}
+            )
+        },
+        skills=skills,
+        hooks=hooks,
+    )
+
+
+def install_omnigraph(dry_run: bool = False) -> None:
+    """Fetch the pinned omnigraph release into ``~/.local/bin/``.
+
+    Skips the download when a binary is already present and reports the
+    pinned version via ``--version``, so re-running always converges on the
+    current pin without refetching an already-correct binary.
+    """
+    local_bin = Path.home() / ".local" / "bin"
+    dest = local_bin / "omnigraph"
+    _download_omnigraph(dest, dry_run)
+
+
+def _download_omnigraph(dest: Path, dry_run: bool) -> None:
+    from rich.console import Console
+
+    console = Console()
+
+    if _installed_version(dest) == _OMNIGRAPH_VERSION:
+        console.print(
+            f"  [dim]omnigraph[/dim] — {dest} already at v{_OMNIGRAPH_VERSION}, skipping"
+        )
+        return
+
+    key = (platform.system().lower(), platform.machine().lower())
+    asset = _OMNIGRAPH_ASSETS.get(key)
+    if asset is None:
+        console.print(
+            f"  [yellow]omnigraph[/yellow] — no pre-built binary for"
+            f" {key[0]}/{key[1]}; install manually"
+        )
+        return
+
+    url = (
+        f"https://github.com/ModernRelay/omnigraph/releases/download"
+        f"/v{_OMNIGRAPH_VERSION}/{asset}"
+    )
+    console.print(f"  downloading omnigraph v{_OMNIGRAPH_VERSION} …")
+
+    if dry_run:
+        console.print(f"  [green]omnigraph[/green] → {dest} [dim](dry-run)[/dim]")
+        return
+
+    dest.parent.mkdir(parents=True, exist_ok=True)
+    tmp_dest = dest.with_name(dest.name + ".tmp")
+    try:
+        extracted = False
+        with tempfile.TemporaryDirectory() as tmp:
+            archive = Path(tmp) / asset
+            try:
+                with (
+                    urllib.request.urlopen(url, timeout=60) as resp,
+                    open(archive, "wb") as fh,
+                ):
+                    fh.write(resp.read())
+            except Exception as exc:  # noqa: BLE001
+                console.print(
+                    f"  [red]omnigraph download failed[/red] ({exc}); install manually"
+                )
+                return
+            with tarfile.open(archive) as tf:
+                for member in tf.getmembers():
+                    if member.name.split("/")[-1] == "omnigraph" and not member.isdir():
+                        f = tf.extractfile(member)
+                        if f:
+                            tmp_dest.write_bytes(f.read())
+                            extracted = True
+                        break
+        if extracted:
+            tmp_dest.chmod(0o755)
+            tmp_dest.replace(dest)
+            console.print(f"  [green]omnigraph[/green] → {dest}")
+        else:
+            console.print(
+                "  [red]omnigraph[/red] — binary not found in archive; install manually"
+            )
+    except Exception as exc:  # noqa: BLE001
+        console.print(
+            f"  [red]omnigraph download failed[/red] ({exc}); install manually"
+        )
+    finally:
+        tmp_dest.unlink(missing_ok=True)

witan_code/skills/witan-code/SKILL.md

@@ -0,0 +1,97 @@
+---
+name: witan-code
+description: >
+  Tree-sitter code graph for symbol lookups, caller graphs, change-impact
+  analysis, and cross-repo contract tracing. Use instead of grep/Explore when
+  you need exact symbol definitions, who-calls-what, blast radius before an
+  edit, or which repo provides/consumes a shared env var, endpoint, package, or
+  service. `/witan-code` reports whether the current repo is indexed and lists
+  the available `code_*` tools; `/witan-code reindex` forces a full rebuild.
+  Backed by the witan-code MCP server (code_* tools).
+license: BSD-3-Clause
+metadata:
+  category: workflow
+---
+
+# Code Graph
+
+A per-repo, tree-sitter-derived graph of symbols (functions, methods, classes,
+modules) and their relationships (`Calls`, `References`, `Imports`,
+`Inherits`), plus a cross-repo bridge linking services through shared
+contracts (env vars, HTTP endpoints, packages, deployments). Indexing is
+automatic — a `SessionStart` hook seeds/refreshes the whole repo in the
+background, and a `PostToolUse` hook incrementally reindexes each file you
+edit — so you rarely need to invoke the CLI yourself.
+
+## When to use this vs. grep / the `Explore` agent
+
+Reach for `code_*` tools when the question is **structural**, not textual:
+
+- "Where is `Service.run` defined?" → `code_find_definition` / `code_search_symbol`
+- "What calls this function, anywhere in the repo?" → `code_callers` / `code_find_references`
+- "If I change this, what breaks?" (transitive blast radius) → `code_impact`
+- "What symbols does this file define?" → `code_symbols_in_file`
+- "Which other repo reads this env var / calls this endpoint / imports this package?" → `code_interface_consumers` / `code_interface_providers` / `code_cross_repo_impact`
+
+Grep is still the right tool for literal string/comment searches, one-off text
+matches, or a repo with no code graph yet. The two are complementary: grep
+finds text; `code_*` tools resolve **symbols** and their **relationships**,
+which grep cannot do (it can't tell you a function's transitive callers or
+which service consumes an endpoint another service serves).
+
+**Caveat:** `Calls`/`References`/`Imports`/`Inherits` edges are heuristic
+(syntactic name resolution, not a true call graph) — treat impact/caller
+results as a high-recall starting point, not a verified answer. `Defines` and
+`Contains` are exact.
+
+## On invocation
+
+- No args → **Check readiness**, then show the tool reference below.
+- `reindex` → call the `code_reindex` MCP tool (or `witan-code reindex` if
+  running the CLI directly) to force a full rebuild of the current repo,
+  ignoring content hashes. Use when the graph looks stale and you don't want
+  to wait for the incremental hooks to catch up.
+
+## Check readiness
+
+Before relying on results, confirm the current repo has a graph: call
+`code_symbols_in_file` on a file you know exists, or `code_search_symbol` with
+a term you expect to match. An empty result on a file/symbol you know exists
+usually means indexing hasn't finished yet (the `SessionStart` hook runs
+detached in the background on a fresh repo) — wait a few seconds and retry
+before concluding the graph is broken.
+
+## Tool reference
+
+| Question | Tool |
+|---|---|
+| Find a symbol by name | `code_find_definition(name)` / `code_search_symbol(query)` (BM25) |
+| What's in this file? | `code_symbols_in_file(path)` |
+| Who references/calls this symbol? | `code_find_references(symbol_id)` (References+Calls) / `code_callers(symbol_id)` (Calls only) |
+| Blast radius of a change | `code_impact(symbol_id, max_depth=5, max_nodes=200)` — transitive callers via BFS |
+| Force a reindex | `code_reindex(path=None)` |
+
+Cross-repo (reads the shared bridge store; `kind` is one of `env_var` /
+`endpoint` / `package` / `service`):
+
+| Question | Tool |
+|---|---|
+| Who provides this contract? | `code_interface_providers(kind, key)` |
+| Who consumes it? | `code_interface_consumers(kind, key)` |
+| Every binding for this symbol's contracts, across repos | `code_cross_repo_impact(symbol_id)` |
+| Search bindings by key | `code_interface_search(query, kind=None)` |
+
+Every tool resolves the per-repo store from the current working directory and
+returns `[]`/`null` gracefully when nothing is indexed yet — an empty result
+is not necessarily an error, see **Check readiness** above.
+
+## Linking to witan (tasks and memories)
+
+`code_find_definition` / `code_search_symbol` return a `symbol_id` of the form
+`<repo>#<path/to/file.py>::<QualifiedName>`. Attach it to a witan task
+(`task_create(..., symbol_refs=[...])`, see `/witan-task`) or memory
+(`memory_store(..., symbol_refs=[...])`, see `/witan-memory`) so the work or
+lesson is discoverable from the code later. Going the other way,
+`symbol_context(symbol_id)` (a witan tool) lists the tasks and memories
+already attached to a symbol — call it before editing code that might have
+open work or known gotchas attached.

witan_code/stitch.py

@@ -0,0 +1,177 @@
+"""Stage 2 — cross-repo symbol stitching at read time (docs/SYMBOL_TABLE.md).
+
+Joins ``RepoSymbol`` rows across the whole bridge store to compute precise
+cross-repo edges WITHOUT ever writing them: each repo's ``external``
+(unresolved reference) rows are matched against every OTHER repo's
+``exported`` rows by canonical symbol identity. This is the read-time join
+Stage 1 exists to serve — the RANGER/SCIP pattern of deferring cross-repo
+linking to query time instead of guessing at extraction time.
+
+Join keys (docs/SYMBOL_TABLE.md § Stage-2 join contract):
+  * ``env`` / ``svc`` — exact ``(scheme, descriptor)``.
+  * ``http`` / ``pkg`` — ``(scheme, key_norm)``; ``http`` additionally
+    requires method compatibility (a consumer method of ``*`` matches any
+    provider method) since key_norm collapses the method-bearing descriptor
+    down to the bare path. ``pkg`` descriptors are always ``.``
+    (SYMBOL_FORMAT.md), so key_norm — which carries the package name for
+    both roles — is the only usable join key for packages.
+
+Version disambiguation follows SYMBOL_FORMAT.md decision 1: prefer an exact
+version match, then ``main``, else flag the group ``ambiguous_version``
+rather than guessing a winner. Every candidate is still returned as its own
+edge (this project's consistent pattern of surfacing all cross-repo data and
+letting callers filter — see ``code_cross_repo_impact``); ``preferred`` marks
+which candidate(s) survive the version-preference rule and ``match_count``
+lets a caller tell a clean single match from a fan-out before deciding
+whether to trust it.
+
+Existing URL-heuristic extraction (``visualize.cross_repo_edges``, keyed on
+the coarser ``(kind, key_norm)`` binding grouping) is the Stage-3 fallback
+tier for external symbols that fail to join here — see
+``get_unresolved_symbols`` below.
+"""
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class PreciseEdge:
+    consumer_repo: str
+    consumer_symbol: str
+    provider_repo: str
+    provider_symbol: str
+    kind: str
+    key_norm: str
+    scheme: str
+    match_count: int
+    preferred: bool
+    ambiguous_version: bool
+    # One Stage-1 exemplar occurrence per side (RepoSymbol keeps only one, not
+    # every occurrence — see SYMBOL_TABLE.md); omitted where the store row
+    # predates file/line or has none. Consumed by witan_code.edges to build
+    # the typed-edge evidence list for the :CALLS/precise tier.
+    evidence: tuple[dict, ...] = ()
+
+    def as_dict(self) -> dict:
+        return {
+            "consumer_repo": self.consumer_repo,
+            "consumer_symbol": self.consumer_symbol,
+            "provider_repo": self.provider_repo,
+            "provider_symbol": self.provider_symbol,
+            "kind": self.kind,
+            "key_norm": self.key_norm,
+            "scheme": self.scheme,
+            "match_count": self.match_count,
+            "preferred": self.preferred,
+            "ambiguous_version": self.ambiguous_version,
+            "evidence": list(self.evidence),
+        }
+
+
+def _method(descriptor: str | None) -> str | None:
+    """The leading method token of an http descriptor, or None if there isn't one."""
+    if not descriptor:
+        return None
+    method, _, rest = descriptor.partition(" ")
+    return method if rest else None
+
+
+def _http_compatible(
+    consumer_descriptor: str | None, provider_descriptor: str | None
+) -> bool:
+    consumer_method = _method(consumer_descriptor)
+    return consumer_method in (None, "*") or consumer_method == _method(
+        provider_descriptor
+    )
+
+
+def _join_key(row: dict) -> tuple:
+    scheme = row["scheme"]
+    if scheme in ("env", "svc"):
+        return (scheme, "descriptor", row["descriptor"])
+    return (scheme, "key_norm", row["key_norm"])
+
+
+def _select_preferred(
+    consumer_version: str | None, candidates: list[dict]
+) -> tuple[set, bool]:
+    """Indices of the preferred candidate(s) plus whether the group is ambiguous.
+
+    SYMBOL_FORMAT.md decision 1: prefer an exact version match, then ``main``,
+    else every remaining candidate is preferred and the group is ambiguous
+    (more than one — don't guess a winner).
+    """
+
+    def where(pred) -> set:
+        return {i for i, c in enumerate(candidates) if pred(c)}
+
+    if consumer_version not in (".", "", None):
+        exact = where(lambda c: c["version"] == consumer_version)
+        if exact:
+            return exact, len(exact) > 1
+    main = where(lambda c: c["version"] == "main")
+    if main:
+        return main, len(main) > 1
+    return set(range(len(candidates))), len(candidates) > 1
+
+
+def _evidence(ext: dict, prov: dict) -> tuple[dict, ...]:
+    out = []
+    for row in (ext, prov):
+        if row.get("file"):
+            out.append(
+                {"repo": row["repo"], "file": row["file"], "line": row.get("line")}
+            )
+    return tuple(out)
+
+
+def resolve(rows: list[dict]) -> tuple[list[PreciseEdge], list[dict]]:
+    """Join a full ``RepoSymbol`` dump (``all_repo_symbols``) into edges + gaps.
+
+    Returns ``(precise_edges, unresolved)``: every external row that matched
+    at least one exported row from another repo becomes one ``PreciseEdge``
+    per candidate; external rows with zero candidates are returned verbatim
+    in ``unresolved`` (the raw ``RepoSymbol`` dict) for
+    ``get_unresolved_symbols`` / Stage-3 fallback.
+    """
+    exported: dict[tuple, list[dict]] = {}
+    external: list[dict] = []
+    for row in rows:
+        if row["role"] == "exported":
+            exported.setdefault(_join_key(row), []).append(row)
+        else:
+            external.append(row)
+
+    edges: list[PreciseEdge] = []
+    unresolved: list[dict] = []
+    for ext in external:
+        candidates = [
+            prov
+            for prov in exported.get(_join_key(ext), [])
+            if prov["repo"] != ext["repo"]
+            and (
+                ext["scheme"] != "http"
+                or _http_compatible(ext["descriptor"], prov["descriptor"])
+            )
+        ]
+        if not candidates:
+            unresolved.append(ext)
+            continue
+        preferred_idx, ambiguous = _select_preferred(ext["version"], candidates)
+        for i, prov in enumerate(candidates):
+            edges.append(
+                PreciseEdge(
+                    consumer_repo=ext["repo"],
+                    consumer_symbol=ext["symbol"],
+                    provider_repo=prov["repo"],
+                    provider_symbol=prov["symbol"],
+                    kind=ext["kind"],
+                    key_norm=ext.get("key_norm") or prov.get("key_norm") or "",
+                    scheme=ext["scheme"],
+                    match_count=len(candidates),
+                    preferred=i in preferred_idx,
+                    ambiguous_version=ambiguous,
+                    evidence=_evidence(ext, prov),
+                )
+            )
+    return edges, unresolved

witan_code/store.py

@@ -0,0 +1,116 @@
+"""Per-repo store resolution and lazy initialisation."""
+
+import subprocess
+from pathlib import Path
+
+from . import config as cfg_module
+from .graph import OmnigraphClient
+
+
+def store_for_repo(slug: str, config: cfg_module.Config | None = None) -> Path:
+    """Return the store path for ``slug`` without creating it."""
+    cfg = config or cfg_module.load()
+    return cfg_module.store_path(slug, cfg.code_dir)
+
+
+def store_exists(slug: str, config: cfg_module.Config | None = None) -> bool:
+    return store_for_repo(slug, config).exists()
+
+
+def ensure_store(slug: str, config: cfg_module.Config | None = None) -> Path:
+    """Resolve the per-repo store, initialising it from the schema if missing.
+
+    Mirrors install.sh: ``omnigraph init --schema <schema> <store>``. The flag
+    style is copied from the memory install script (the only place a per-store
+    init is evidenced); see ASSUMPTION note below.
+    """
+    cfg = config or cfg_module.load()
+    store = cfg_module.store_path(slug, cfg.code_dir)
+    binary = _binary()
+
+    if not store.exists():
+        store.parent.mkdir(parents=True, exist_ok=True)
+        # ASSUMPTION: `omnigraph init --schema <file> <store>` is the per-store
+        # init form, matching witan/install.sh.
+        subprocess.run(
+            [binary, "init", "--schema", str(cfg.schema_file), str(store)],
+            check=True,
+            capture_output=True,
+            text=True,
+        )
+        # Force apply on first creation — stamp will be written below.
+        _schema_apply(binary, cfg.schema_file, store)
+    else:
+        # Only re-apply when the schema file has changed since the last apply.
+        # schema apply is additive/idempotent but spawns a subprocess on every
+        # PostToolUse reindex; the mtime sidecar avoids the cost on hot paths.
+        _schema_apply_if_changed(binary, cfg.schema_file, store)
+
+    # Record the canonical repo URI in a sidecar so listings can show it even for
+    # a 0-file store (sanitize_slug is lossy — its `_` collapse isn't reversible).
+    repo_sidecar(store).write_text(slug)
+    return store
+
+
+def repo_sidecar(store: Path) -> Path:
+    """Sidecar file next to a store holding its canonical repo URI."""
+    return store.parent / f"{store.name}.repo"
+
+
+def _schema_stamp(store: Path) -> Path:
+    return store.parent / f"{store.name}.schema_mtime"
+
+
+def _schema_apply(binary: str, schema_file: Path, store: Path) -> None:
+    res = subprocess.run(
+        [binary, "schema", "apply", "--schema", str(schema_file), str(store)],
+        capture_output=True,
+        text=True,
+    )
+    if res.returncode == 0:
+        _schema_stamp(store).write_text(str(schema_file.stat().st_mtime))
+
+
+def _schema_apply_if_changed(binary: str, schema_file: Path, store: Path) -> None:
+    stamp = _schema_stamp(store)
+    current_mtime = str(schema_file.stat().st_mtime)
+    if stamp.exists() and stamp.read_text().strip() == current_mtime:
+        return
+    _schema_apply(binary, schema_file, store)
+
+
+def bridge_store(config: cfg_module.Config | None = None) -> Path:
+    """Return the shared bridge store path without creating it."""
+    cfg = config or cfg_module.load()
+    return cfg_module.bridge_store_path(cfg.code_dir)
+
+
+def ensure_bridge_store(config: cfg_module.Config | None = None) -> Path:
+    """Resolve the shared bridge store, initialising it from bridge-schema.pg.
+
+    Mirrors ``ensure_store`` but uses the bridge schema and the fixed
+    ``_bridge.omni`` filename. ``schema apply`` builds the FTS index on
+    ``key_norm`` that ``search_bindings`` needs.
+    """
+    cfg = config or cfg_module.load()
+    store = cfg_module.bridge_store_path(cfg.code_dir)
+    binary = _binary()
+    if store.exists():
+        # Pick up additive schema changes (new nodes/fields) on existing
+        # stores; the mtime stamp keeps hot reindex paths subprocess-free.
+        _schema_apply_if_changed(binary, cfg.bridge_schema_file, store)
+        return store
+
+    store.parent.mkdir(parents=True, exist_ok=True)
+    subprocess.run(
+        [binary, "init", "--schema", str(cfg.bridge_schema_file), str(store)],
+        check=True,
+        capture_output=True,
+        text=True,
+    )
+    _schema_apply(binary, cfg.bridge_schema_file, store)
+    return store
+
+
+def _binary() -> str:
+    return OmnigraphClient._find_binary()