groundworkers 0.1.0__py3-none-any.whl

groundworkers/tools/embedding_tools.py

@@ -0,0 +1,83 @@
+from __future__ import annotations
+
+from typing import Any
+
+from groundworkers.adapters.omop_emb import OmopEmbAdapter
+from groundworkers.base.errors import GroundworkersError
+from groundworkers.base.server import GroundcrewServer
+
+
+def register_embedding_tools(server: GroundcrewServer, emb_adapter: OmopEmbAdapter) -> None:
+    @server.tool("embedding_index_status")
+    def embedding_index_status() -> dict[str, Any]:
+        """Returns status of the embedding backend and registered models."""
+        try:
+            return emb_adapter.index_status()
+        except GroundworkersError as exc:
+            return exc.to_dict()
+        except Exception as exc:
+            return {"error": True, "code": "QUERY_ERROR", "message": repr(exc)}
+
+    @server.tool("embedding_neighbours")
+    def embedding_neighbours(concept_id: int, limit: int = 10, model_name: str | None = None) -> dict[str, Any]:
+        """Returns nearest embedding-space neighbours for one OMOP concept."""
+        if concept_id <= 0:
+            return {"error": True, "code": "INVALID_INPUT", "message": "concept_id must be a positive integer"}
+        safe_limit = max(1, min(limit, 50))
+        if model_name is not None and not model_name.strip():
+            return {"error": True, "code": "INVALID_INPUT", "message": "model_name must be a non-empty string"}
+        try:
+            return emb_adapter.get_neighbours(
+                concept_id=concept_id,
+                limit=safe_limit,
+                model_name=model_name,
+            )
+        except GroundworkersError as exc:
+            return exc.to_dict()
+        except Exception as exc:
+            return {"error": True, "code": "QUERY_ERROR", "message": repr(exc)}
+
+    @server.tool("embedding_search")
+    def embedding_search(
+        query: str,
+        limit: int = 10,
+        domain: str | None = None,
+        vocabulary: str | None = None,
+        standard_only: bool = False,
+        active_only: bool = True,
+        model_name: str | None = None,
+    ) -> dict[str, Any]:
+        """Searches the embedding index by encoding a query string on the fly."""
+        if not query.strip():
+            return {"error": True, "code": "INVALID_INPUT", "message": "query must be a non-empty string"}
+        safe_limit = max(1, min(limit, 50))
+        try:
+            return emb_adapter.search(
+                query=query,
+                limit=safe_limit,
+                domain=domain,
+                vocabulary=vocabulary,
+                standard_only=standard_only,
+                active_only=active_only,
+                model_name=model_name,
+            )
+        except NotImplementedError as exc:
+            return {"error": True, "code": "BACKEND_UNAVAIL", "message": str(exc)}
+        except GroundworkersError as exc:
+            return exc.to_dict()
+        except Exception as exc:
+            return {"error": True, "code": "QUERY_ERROR", "message": repr(exc)}
+
+    @server.tool("embedding_encode")
+    def embedding_encode(text: str, model_name: str | None = None) -> dict[str, Any]:
+        """Encodes free text into one embedding vector using the configured model client."""
+        if not text.strip():
+            return {"error": True, "code": "INVALID_INPUT", "message": "text must be a non-empty string"}
+        if model_name is not None and not model_name.strip():
+            return {"error": True, "code": "INVALID_INPUT", "message": "model_name must be a non-empty string"}
+        try:
+            return emb_adapter.encode(text=text, model_name=model_name)
+        except GroundworkersError as exc:
+            return exc.to_dict()
+        except Exception as exc:
+            return {"error": True, "code": "QUERY_ERROR", "message": repr(exc)}

groundworkers/tools/resolver_tools.py

@@ -0,0 +1,90 @@
+from __future__ import annotations
+
+from typing import Any
+
+from groundworkers.adapters.omop_graph import OmopGraphAdapter
+from groundworkers.base.errors import GroundworkersError
+from groundworkers.base.server import GroundcrewServer
+
+
+def register_resolver_tools(server: GroundcrewServer, graph_adapter: OmopGraphAdapter) -> None:
+    """Register free-text concept resolution tools against the MCP server.
+
+    These tools map unstructured text (clinical terms, natural language, partial
+    descriptions) to OMOP standard concepts. They are probabilistic — results
+    are ranked candidates, not guaranteed matches.
+
+    For deterministic lookups from known identifiers (concept_id, vocab+code,
+    hierarchy traversal) see concept_tools.py.
+    For agent-composable primitive search operations see search_tools.py.
+    """
+
+    @server.tool("concept_ground")
+    def concept_ground(
+        query: str,
+        limit: int = 5,
+        domain: str | None = None,
+        vocabulary_id: str | None = None,
+        parent_ids: list[int] | None = None,
+    ) -> dict[str, Any]:
+        """Ground free text to matching OMOP standard concepts ranked by relevance.
+
+        Runs a tiered resolver pipeline (Exact → FullText → Embedding → Partial)
+        and short-circuits on the first tier that returns results. Each tier
+        also matches against concept synonyms.
+
+        match_kind in each result indicates which resolver tier produced it:
+          EXACT             — case-insensitive exact match on concept_name or synonym
+          FULLTEXT          — PostgreSQL FTS (requires tsvector sidecar column)
+          EMBEDDING_NEAREST — nearest-neighbour embedding search
+          PARTIAL           — iLIKE fragment match (last resort)
+
+        Each result includes scoring fields (total_score, relevance, parsimony_penalty,
+        broadness_bonus, separation, embedding_score) and standardized_from when the
+        grounded concept was mapped from a non-standard source concept.
+
+        grounding_explanation summarises which resolver tier matched, whether embedding
+        scoring was active, and which parent_ids constrained the search space.
+
+        parent_ids: optional list of OMOP concept_ids that act as required ancestors.
+          Only concepts that are descendants of at least one of these will be returned.
+          Use this to constrain grounding to a specific clinical sub-hierarchy — e.g.
+          pass the concept_id for "Neoplastic disease" to ensure only oncology results
+          are returned, or the concept_id for a specific drug class to scope a drug
+          lookup to that class.
+          When omitted the search is anchored to the domain root (or all known domain
+          roots when domain is also omitted).
+
+        For finer control over resolver selection and quality thresholds, use the
+        agent-composable primitives: concept_search_exact, concept_search_fulltext,
+        embedding_search, and concept_navigate_to_standard.
+        """
+        stripped = query.strip()
+        if not stripped:
+            return {
+                "error": True,
+                "code": "INVALID_INPUT",
+                "message": "query must be a non-empty string",
+            }
+        if parent_ids is not None and any(pid <= 0 for pid in parent_ids):
+            return {
+                "error": True,
+                "code": "INVALID_INPUT",
+                "message": "all parent_ids must be positive integers",
+            }
+        safe_limit = max(1, min(limit, 20))
+        resolved_parent_ids = tuple(parent_ids) if parent_ids else None
+        try:
+            ground_result = graph_adapter.ground(
+                stripped, safe_limit, domain or None, vocabulary_id or None,
+                parent_ids=resolved_parent_ids,
+            )
+            return {
+                "query": stripped,
+                "results": ground_result["results"],
+                "grounding_explanation": ground_result["grounding_explanation"],
+            }
+        except GroundworkersError as exc:
+            return exc.to_dict()
+        except Exception as exc:
+            return {"error": True, "code": "QUERY_ERROR", "message": repr(exc)}

groundworkers/tools/search_tools.py

@@ -0,0 +1,163 @@
+from __future__ import annotations
+
+from typing import Any
+
+from groundworkers.adapters.omop_vocab import (
+    OmopVocabAdapter,
+    OmopVocabError,
+    serialise_concept_match,
+    serialise_standard_mapping,
+)
+from groundworkers.base.server import GroundcrewServer
+
+
+def register_search_tools(server: GroundcrewServer, vocab_adapter: OmopVocabAdapter) -> None:
+    """Register agent-composable primitive search tools against the MCP server."""
+
+    @server.tool("concept_search_exact")
+    def concept_search_exact(
+        query: str,
+        domain: str | None = None,
+        vocabulary_id: str | None = None,
+        standard_only: bool = False,
+        include_synonyms: bool = True,
+        limit: int = 20,
+    ) -> dict[str, Any]:
+        """
+        Case-insensitive exact match of a query string against concept_name and
+        (optionally) concept_synonym_name.
+
+        Unlike concept_ground, standard_only defaults to false — results include
+        non-standard concepts so the caller can inspect the standard_concept flag
+        and decide whether to call concept_navigate_to_standard.
+
+        match_source is "name" when the concept_name matched, "synonym" when a
+        concept_synonym_name matched. matched_synonym contains the synonym string
+        that triggered the match.
+        """
+        if not query.strip():
+            return {
+                "error": True,
+                "code": "INVALID_INPUT",
+                "message": "query must be a non-empty string",
+            }
+        safe_limit = max(1, min(limit, 50))
+        try:
+            results = vocab_adapter.search_exact(
+                query,
+                domain=domain or None,
+                vocabulary_id=vocabulary_id or None,
+                standard_only=standard_only,
+                include_synonyms=include_synonyms,
+                limit=safe_limit,
+            )
+            return {
+                "query": query.strip(),
+                "results": [serialise_concept_match(r) for r in results],
+            }
+        except ValueError as exc:
+            return {"error": True, "code": "INVALID_INPUT", "message": str(exc)}
+        except OmopVocabError as exc:
+            return {"error": True, "code": "QUERY_ERROR", "message": str(exc)}
+        except Exception as exc:
+            return {"error": True, "code": "QUERY_ERROR", "message": repr(exc)}
+
+    @server.tool("concept_search_fulltext")
+    def concept_search_fulltext(
+        query: str,
+        domain: str | None = None,
+        vocabulary_id: str | None = None,
+        standard_only: bool = False,
+        include_synonyms: bool = True,
+        min_rank: float = 0.0,
+        limit: int = 20,
+    ) -> dict[str, Any]:
+        """
+        PostgreSQL full-text search against the concept_name tsvector sidecar column.
+
+        Returns results with ts_rank exposed so the caller can apply its own quality
+        threshold (e.g. discard results where ts_rank < 0.05).
+
+        tsvector_available indicates whether the GIN-indexed sidecar column was
+        detected. When false, results is always [] and the caller should fall
+        through to embedding_search or concept_search_exact.
+
+        min_rank is an optional server-side pre-filter (avoids returning very
+        large result sets); the caller's own threshold may be stricter.
+
+        standard_only defaults to false — see concept_search_exact.
+        """
+        if not query.strip():
+            return {
+                "error": True,
+                "code": "INVALID_INPUT",
+                "message": "query must be a non-empty string",
+            }
+        if not (0.0 <= min_rank <= 1.0):
+            return {
+                "error": True,
+                "code": "INVALID_INPUT",
+                "message": "min_rank must be between 0.0 and 1.0",
+            }
+        safe_limit = max(1, min(limit, 50))
+        try:
+            results, fts_available = vocab_adapter.search_fulltext(
+                query,
+                domain=domain or None,
+                vocabulary_id=vocabulary_id or None,
+                standard_only=standard_only,
+                include_synonyms=include_synonyms,
+                min_rank=min_rank,
+                limit=safe_limit,
+            )
+            return {
+                "query": query.strip(),
+                "tsvector_available": fts_available,
+                "results": [serialise_concept_match(r) for r in results],
+            }
+        except ValueError as exc:
+            return {"error": True, "code": "INVALID_INPUT", "message": str(exc)}
+        except OmopVocabError as exc:
+            return {"error": True, "code": "QUERY_ERROR", "message": str(exc)}
+        except Exception as exc:
+            return {"error": True, "code": "QUERY_ERROR", "message": repr(exc)}
+
+    @server.tool("concept_navigate_to_standard")
+    def concept_navigate_to_standard(
+        concept_ids: list[int],
+    ) -> dict[str, Any]:
+        """
+        Given a list of concept_ids, return their standard OMOP equivalents by
+        following "Maps to" relationship edges.
+
+        For concepts that are already standard: standard_concepts contains the
+        concept itself (relationship_id = "self").
+        For concepts with no "Maps to" mapping: standard_concepts is [].
+        concept_ids not found in the vocabulary are silently omitted from results.
+
+        This is the batch-by-concept-id form of concept_map_to_standard. Use it
+        after concept_search_exact, concept_search_fulltext, or embedding_search
+        to resolve non-standard candidates to their standard equivalents in a
+        single round-trip.
+        """
+        if not concept_ids:
+            return {"results": []}
+        if len(concept_ids) > 100:
+            return {
+                "error": True,
+                "code": "INVALID_INPUT",
+                "message": "concept_ids must contain at most 100 entries",
+            }
+        if any(cid <= 0 for cid in concept_ids):
+            return {
+                "error": True,
+                "code": "INVALID_INPUT",
+                "message": "all concept_ids must be positive integers",
+            }
+        try:
+            mappings = vocab_adapter.navigate_to_standard(concept_ids)
+            return {"results": [serialise_standard_mapping(m) for m in mappings]}
+        except OmopVocabError as exc:
+            return {"error": True, "code": "QUERY_ERROR", "message": str(exc)}
+        except Exception as exc:
+            return {"error": True, "code": "QUERY_ERROR", "message": repr(exc)}

groundworkers/tools/system_tools.py

@@ -0,0 +1,67 @@
+"""System-level MCP tools: system_status and system_vocabulary_catalogue.
+
+These tools are always registered regardless of adapter availability, so
+callers always get a structured response (never "unknown tool").
+
+system_status — reports availability of every configured adapter.
+system_vocabulary_catalogue — returns the full OMOP vocabulary/domain/class
+  catalogue from OmopGraphAdapter.  Requires omop_graph to be configured.
+"""
+from __future__ import annotations
+
+from typing import Any
+
+from groundworkers.adapters.omop_emb import OmopEmbAdapter
+from groundworkers.adapters.omop_graph import OmopGraphAdapter
+from groundworkers.base.errors import GroundworkersError
+from groundworkers.base.server import GroundcrewServer
+
+
+def register_system_tools(
+    server: GroundcrewServer,
+    graph_adapter: OmopGraphAdapter | None = None,
+    emb_adapter: OmopEmbAdapter | None = None,
+) -> None:
+    @server.tool("system_status")
+    def system_status() -> dict[str, Any]:
+        """Returns availability of each configured adapter/backend."""
+        adapters: dict[str, Any] = {}
+
+        if graph_adapter is not None:
+            try:
+                adapters["omop_graph"] = {"available": graph_adapter.is_available()}
+            except Exception as exc:
+                adapters["omop_graph"] = {"available": False, "reason": repr(exc)}
+        else:
+            adapters["omop_graph"] = {"available": False, "reason": "not configured"}
+
+        if emb_adapter is not None:
+            try:
+                status = emb_adapter.index_status()
+                adapters["omop_emb"] = {
+                    "available": status["available"],
+                    "models": status.get("models", []),
+                }
+            except Exception as exc:
+                adapters["omop_emb"] = {"available": False, "reason": repr(exc)}
+        else:
+            adapters["omop_emb"] = {"available": False, "reason": "not configured"}
+
+        overall = any(v.get("available") for v in adapters.values())
+        return {"available": overall, "adapters": adapters}
+
+    @server.tool("system_vocabulary_catalogue")
+    def system_vocabulary_catalogue() -> dict[str, Any]:
+        """Returns all OMOP vocabularies, domains, and concept classes."""
+        if graph_adapter is None:
+            return {
+                "error": True,
+                "code": "BACKEND_UNAVAIL",
+                "message": "omop_graph adapter is not configured",
+            }
+        try:
+            return graph_adapter.get_vocabulary_catalogue()
+        except GroundworkersError as exc:
+            return exc.to_dict()
+        except Exception as exc:
+            return {"error": True, "code": "QUERY_ERROR", "message": repr(exc)}

groundworkers-0.1.0.dist-info/METADATA

@@ -0,0 +1,116 @@
+Metadata-Version: 2.4
+Name: groundworkers
+Version: 0.1.0
+Summary: Groundworkers MCP server — read-only agentive access to OMOP vocabularies, concept graphs, and embeddings.
+Requires-Python: >=3.12
+Description-Content-Type: text/markdown
+Requires-Dist: mcp[cli]<2,>=1
+Requires-Dist: pydantic<3,>=2
+Requires-Dist: pyyaml<7,>=6
+Requires-Dist: SQLAlchemy<3,>=2
+Requires-Dist: psycopg[binary]<4,>=3.1
+Requires-Dist: omop-graph>=1.1.0
+Requires-Dist: omop-emb>=1.0.0
+Provides-Extra: embedding-pgvector
+Requires-Dist: omop-emb[pgvector]>=1.0.0; extra == "embedding-pgvector"
+Provides-Extra: embedding-faiss
+Requires-Dist: omop-emb[faiss-cpu]>=1.0.0; extra == "embedding-faiss"
+Provides-Extra: dev
+Requires-Dist: pytest<9,>=8; extra == "dev"
+
+# groundworkers
+
+**groundworkers** is an atomic, read-only MCP (Model Context Protocol) tool library for
+navigating the OMOP vocabularies.  It exposes OMOP vocabulary lookups, embedding similarity search, 
+cohort concept references, and system status as typed MCP tools that any MCP client can call —
+including [groundcrew](https://github.com/AustralianCancerDataNetwork/groundcrew),
+Claude Code, and autonomous agents.
+
+Read-only.  No patient-level data.  No write operations.
+
+## What it exposes
+
+| Group | Tools |
+|---|---|
+| **Concept** | `concept_get`, `concept_by_code`, `concept_ancestors`, `concept_descendants`, `concept_relationships`, `concept_equivalency_path`, `concept_path`, `concept_map_to_standard`, `concept_neighbors` |
+| **Resolver** | `concept_ground` (with `parent_ids`, scoring fields, and `grounding_explanation`) |
+| **Search** | `concept_search_exact`, `concept_search_fulltext`, `concept_navigate_to_standard` |
+| **Embedding** | `embedding_index_status`, `embedding_neighbours`, `embedding_search`, `embedding_encode` |
+| **Cohort** | `cohort_find_concept_references` |
+| **System** | `system_status`, `system_vocabulary_catalogue` |
+
+Tools are registered conditionally — if an adapter is not configured, its tools are
+simply not registered.  `system_status` and `system_vocabulary_catalogue` are always
+registered so clients can always query adapter availability.
+
+## Quick start
+
+```bash
+uv venv
+uv sync --extra dev --extra embedding-tools
+uv run groundworkers --config config/groundworkers.example.yaml --describe
+```
+
+Start the server:
+
+```bash
+uv run groundworkers --config config/groundworkers.example.yaml
+```
+
+## Example config
+
+```yaml
+omop_graph:
+  db_url: "postgresql+psycopg://user:pass@localhost:5432/omop"
+  vocab_schema: omop_vocab
+
+omop_emb:
+  enabled: true
+  backend_type: pgvector
+  db_url: "postgresql+psycopg://user:pass@localhost:5432/omop"
+  default_model_name: qwen3-embedding:0.6b
+  api_base: "http://localhost:11434/v1"
+  api_key: "ollama"
+```
+
+## Install matrix
+
+| Use case | Extras |
+|---|---|
+| Core server only | none |
+| Concept tools | `concept-tools` |
+| Cohort tools | `cohort-tools` |
+| Embedding tools (sqlite-vec) | `embedding-tools` |
+| Embedding tools (pgvector) | `embedding-pgvector` |
+| Embedding tools (FAISS sidecar) | `embedding-faiss` |
+| All tool families | `all-tools` |
+| All + pgvector embeddings | `all-tools-pgvector` |
+| All + FAISS embeddings | `all-tools-faiss` |
+| Development | `dev` |
+| Development + all tools | `dev-all` |
+
+## Layout
+
+```
+src/groundworkers/
+  adapters/          — omop_graph, omop_emb, oa_cohorts adapter classes
+  base/              — GroundcrewServer, errors, results, SQL helpers
+  tools/             — MCP tool registrations by domain
+  config.py          — Pydantic config models (AppConfig, OmopGraphConfig, etc.)
+  server.py          — Server factory and CLI entry point
+config/              — Example YAML configs
+_design/             — Architecture notes and spec documents
+tests/               — Unit and integration tests
+```
+
+## Adapter backends
+
+- **omop-graph** — concept lookup, hierarchy traversal, full-text search
+- **omop-emb** — embedding index (sqlite-vec, pgvector, or FAISS sidecar)
+- **OpenAnalytics cohorts** — cohort concept reference queries (Phase N)
+
+## Companion repos
+
+- [groundcrew](https://github.com/AustralianCancerDataNetwork/groundcrew) — ACP orchestration layer that drives this tool substrate
+- [omop-graph](https://australiancancerdatanetwork.github.io/omop-graph/) — OMOP virtual knowledge graph library
+- [omop-emb](https://australiancancerdatanetwork.github.io/omop-emb/) — OMOP embedding index library

groundworkers-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+groundworkers/__init__.py,sha256=4t_crzhrLum--oyowUMxtjBTzUtWp7oRTF22ewEvJG4,49
+groundworkers/config.py,sha256=WvymBnWqAy8AS787wGJKTBGiIkci0K2dqUzTNwgqoiI,4390
+groundworkers/server.py,sha256=oM6EZIfSZcM40NP9Vk7GA1KZs2-ln27vkSRYtfSidk0,5101
+groundworkers/adapters/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+groundworkers/adapters/omop_emb.py,sha256=Bw_DCuwjJpm9EYTGIvVCFs9VfpNkg7YDJqj7R4mjoxU,9673
+groundworkers/adapters/omop_graph.py,sha256=sJqwPBuzRNt76kqEKX2pPCQSqyEIvfF0TU-3kPil2Yo,31204
+groundworkers/adapters/omop_vocab.py,sha256=NuUlwWs-vRe2t74DBbN8S-rDHkTZcvjT9YotY_cL69k,23557
+groundworkers/base/__init__.py,sha256=cjqp5jap9pDXxa9RNdLWk6zHePCfy7iyJNg4_ufwROI,455
+groundworkers/base/errors.py,sha256=kXWbyf8Nf_9bVm-SJwQeYDs9UGmVIpqytszKPuye80E,437
+groundworkers/base/results.py,sha256=72ZAQdz2BYptBj9sfsUN5P0vcRHsfrZovGNu-frZyuU,802
+groundworkers/base/server.py,sha256=9flE-dpS8S2W-cNCf5X7YfCuS4vwDfMWhKBmOVUJweo,1730
+groundworkers/base/sql.py,sha256=Ry9yWUHX2ylqLM_qGHWz9jnCujuUSS12rnhLtv4D3Mg,4789
+groundworkers/tools/__init__.py,sha256=AbpHGcgLb-kRsJGnwFEktk7uzpZOCcBY74-YBdrKVGs,1
+groundworkers/tools/concept_tools.py,sha256=tKM4eceDGFwftb2zZnSaSR0EM4XKPnEBk-lO2A0knOo,11440
+groundworkers/tools/embedding_tools.py,sha256=f48YUpqXEcvY4oqM588W81mxUypVnz4b_YDdirHMFAw,3729
+groundworkers/tools/resolver_tools.py,sha256=mFMLFbdlBnLvqir1ol7d5hJNeUrA5iy8t4yWsjtKnY0,4200
+groundworkers/tools/search_tools.py,sha256=nIPO5FI69-nCb3wUa-jv1KTuGB-bGIgDoKCqXNBci9Q,6544
+groundworkers/tools/system_tools.py,sha256=8gFitN69SCG_U45oumdqlcG74x86JYYTqopEbkpixYk,2720
+groundworkers-0.1.0.dist-info/METADATA,sha256=DXp8SF8VQN6ittghIO1TfTaqV7ohiCdYcI497cM4qYA,4418
+groundworkers-0.1.0.dist-info/WHEEL,sha256=aeYiig01lYGDzBgS8HxWXOg3uV61G9ijOsup-k9o1sk,91
+groundworkers-0.1.0.dist-info/entry_points.txt,sha256=MYrp7tx1lT05mfSL3Z7qIAVXEdht5m0Hf3FTkdZMebM,60
+groundworkers-0.1.0.dist-info/top_level.txt,sha256=ZtSWb8IJggAZKgS2CLyQnho63WeiAYWPk5jSGizhrLc,14
+groundworkers-0.1.0.dist-info/RECORD,,

groundworkers-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (82.0.1)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

groundworkers-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+groundworkers = groundworkers.server:main

groundworkers-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+groundworkers