willow-mcp 1.0.0__tar.gz

willow_mcp-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sean Campbell
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

willow_mcp-1.0.0/PKG-INFO

@@ -0,0 +1,85 @@
+Metadata-Version: 2.4
+Name: willow-mcp
+Version: 1.0.0
+Summary: Agent-neutral MCP server — SQLite store, Postgres knowledge base, Kart task queue
+Project-URL: Homepage, https://github.com/rudi193-cmd/willow-mcp
+Author: Sean Campbell
+License: MIT
+License-File: LICENSE
+Keywords: knowledge-base,mcp,openclaw,task-queue,willow
+Requires-Python: >=3.11
+Requires-Dist: mcp>=1.0.0
+Requires-Dist: openclaw-sap-gate>=1.0.0
+Requires-Dist: psycopg2-binary>=2.9
+Description-Content-Type: text/markdown
+
+# willow-mcp
+
+Agent-neutral MCP server. SQLite key/value store, Postgres knowledge base, Kart task queue. SAP/1.0 authorization on every tool call.
+
+```bash
+pip install willow-mcp
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `store_put` | Write to SQLite store |
+| `store_get` | Read from SQLite store |
+| `store_list` | List atoms in a collection |
+| `store_search` | Full-text search in a collection |
+| `store_delete` | Delete an atom |
+| `store_search_all` | Search across all collections |
+| `knowledge_ingest` | Add to Postgres knowledge base |
+| `knowledge_search` | Search Postgres knowledge base |
+| `task_submit` | Submit task to Kart queue |
+| `task_status` | Check task status |
+| `task_list` | List pending tasks |
+
+Every tool requires an `app_id` param. Authorization is checked via [SAP/1.0](https://github.com/rudi193-cmd/sap-rfc).
+
+## OpenClaw config
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "willow": {
+        "command": "python3",
+        "args": ["-m", "willow_mcp"],
+        "env": {
+          "WILLOW_PG_DB": "willow",
+          "SAP_SAFE_ROOT": "~/.sap/Applications",
+          "SAP_PGP_FINGERPRINT": "YOUR_KEY_FINGERPRINT"
+        }
+      }
+    }
+  }
+}
+```
+
+## Configuration
+
+| Env var | Default | Description |
+|---------|---------|-------------|
+| `WILLOW_PG_DB` | `willow` | Postgres database name |
+| `WILLOW_PG_USER` | `$USER` | Postgres user (Unix socket auth) |
+| `WILLOW_STORE_ROOT` | `~/.willow/store` | SQLite store directory |
+| `SAP_SAFE_ROOT` | `~/.sap/Applications` | SAFE folder root |
+| `SAP_PGP_FINGERPRINT` | *(empty)* | Pinned GPG fingerprint |
+
+## Authorization
+
+Uses [openclaw-sap-gate](https://github.com/rudi193-cmd/openclaw-sap-gate) (SAP/1.0). Set up a SAFE folder for each app_id:
+
+```bash
+sap-gate init my-app
+# edit ~/.sap/Applications/my-app/safe-app-manifest.json
+# sign it, then:
+sap-gate verify my-app
+```
+
+## License
+
+MIT — Sean Campbell 2026

willow_mcp-1.0.0/README.md

@@ -0,0 +1,70 @@
+# willow-mcp
+
+Agent-neutral MCP server. SQLite key/value store, Postgres knowledge base, Kart task queue. SAP/1.0 authorization on every tool call.
+
+```bash
+pip install willow-mcp
+```
+
+## Tools
+
+| Tool | Description |
+|------|-------------|
+| `store_put` | Write to SQLite store |
+| `store_get` | Read from SQLite store |
+| `store_list` | List atoms in a collection |
+| `store_search` | Full-text search in a collection |
+| `store_delete` | Delete an atom |
+| `store_search_all` | Search across all collections |
+| `knowledge_ingest` | Add to Postgres knowledge base |
+| `knowledge_search` | Search Postgres knowledge base |
+| `task_submit` | Submit task to Kart queue |
+| `task_status` | Check task status |
+| `task_list` | List pending tasks |
+
+Every tool requires an `app_id` param. Authorization is checked via [SAP/1.0](https://github.com/rudi193-cmd/sap-rfc).
+
+## OpenClaw config
+
+```json
+{
+  "mcp": {
+    "servers": {
+      "willow": {
+        "command": "python3",
+        "args": ["-m", "willow_mcp"],
+        "env": {
+          "WILLOW_PG_DB": "willow",
+          "SAP_SAFE_ROOT": "~/.sap/Applications",
+          "SAP_PGP_FINGERPRINT": "YOUR_KEY_FINGERPRINT"
+        }
+      }
+    }
+  }
+}
+```
+
+## Configuration
+
+| Env var | Default | Description |
+|---------|---------|-------------|
+| `WILLOW_PG_DB` | `willow` | Postgres database name |
+| `WILLOW_PG_USER` | `$USER` | Postgres user (Unix socket auth) |
+| `WILLOW_STORE_ROOT` | `~/.willow/store` | SQLite store directory |
+| `SAP_SAFE_ROOT` | `~/.sap/Applications` | SAFE folder root |
+| `SAP_PGP_FINGERPRINT` | *(empty)* | Pinned GPG fingerprint |
+
+## Authorization
+
+Uses [openclaw-sap-gate](https://github.com/rudi193-cmd/openclaw-sap-gate) (SAP/1.0). Set up a SAFE folder for each app_id:
+
+```bash
+sap-gate init my-app
+# edit ~/.sap/Applications/my-app/safe-app-manifest.json
+# sign it, then:
+sap-gate verify my-app
+```
+
+## License
+
+MIT — Sean Campbell 2026

willow_mcp-1.0.0/pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "willow-mcp"
+version = "1.0.0"
+description = "Agent-neutral MCP server — SQLite store, Postgres knowledge base, Kart task queue"
+readme = "README.md"
+license = { text = "MIT" }
+authors = [{ name = "Sean Campbell" }]
+requires-python = ">=3.11"
+keywords = ["mcp", "openclaw", "knowledge-base", "task-queue", "willow"]
+dependencies = [
+    "mcp>=1.0.0",
+    "psycopg2-binary>=2.9",
+    "openclaw-sap-gate>=1.0.0",
+]
+
+[project.scripts]
+willow-mcp = "willow_mcp.server:main"
+
+[project.urls]
+Homepage = "https://github.com/rudi193-cmd/willow-mcp"
+
+[tool.hatch.build.targets.wheel]
+packages = ["src/willow_mcp"]
+
+[tool.pytest.ini_options]
+testpaths = ["tests"]

willow_mcp-1.0.0/src/willow_mcp/__init__.py

@@ -0,0 +1,10 @@
+"""
+willow-mcp — agent-neutral MCP server.
+
+Provides: SQLite key/value store (SOIL), Postgres knowledge base, Kart task queue.
+Auth: SAP/1.0 via openclaw-sap-gate (app_id required on every tool call).
+
+Run: python3 -m willow_mcp
+"""
+
+__version__ = "1.0.0"

willow_mcp-1.0.0/src/willow_mcp/__main__.py

@@ -0,0 +1,3 @@
+"""Entry point: python3 -m willow_mcp"""
+from .server import main
+main()

willow_mcp-1.0.0/src/willow_mcp/db.py

@@ -0,0 +1,131 @@
+"""Database connections — Postgres (Unix socket) and SQLite store."""
+
+import json
+import os
+import sqlite3
+import threading
+import uuid
+from datetime import datetime, timezone
+from pathlib import Path
+from typing import Optional
+
+import psycopg2
+import psycopg2.extras
+
+_pg_conn = None
+_pg_lock = threading.Lock()
+
+
+def get_pg() -> Optional[psycopg2.extensions.connection]:
+    """Return a Postgres connection via Unix socket, or None."""
+    global _pg_conn
+    with _pg_lock:
+        try:
+            if _pg_conn is None or _pg_conn.closed:
+                _pg_conn = psycopg2.connect(
+                    dbname=os.environ.get("WILLOW_PG_DB", "willow"),
+                    user=os.environ.get("WILLOW_PG_USER", os.environ.get("USER", "")),
+                )
+                _pg_conn.autocommit = True
+            _pg_conn.cursor().execute("SELECT 1")
+            return _pg_conn
+        except Exception:
+            _pg_conn = None
+            return None
+
+
+class Store:
+    """SQLite-backed key/value store. One database per collection."""
+
+    def __init__(self, store_root: Optional[str] = None):
+        self.root = Path(store_root or os.environ.get(
+            "WILLOW_STORE_ROOT",
+            Path.home() / ".willow" / "store"
+        ))
+        self.root.mkdir(parents=True, exist_ok=True)
+        self._conns: dict[str, sqlite3.Connection] = {}
+        self._lock = threading.Lock()
+
+    def _conn(self, collection: str) -> sqlite3.Connection:
+        with self._lock:
+            if collection not in self._conns:
+                db_path = self.root / f"{collection}.db"
+                conn = sqlite3.connect(str(db_path), check_same_thread=False)
+                conn.execute("""
+                    CREATE TABLE IF NOT EXISTS atoms (
+                        id TEXT PRIMARY KEY,
+                        domain TEXT NOT NULL DEFAULT 'default',
+                        content TEXT NOT NULL,
+                        meta TEXT DEFAULT '{}',
+                        created TEXT NOT NULL,
+                        updated TEXT NOT NULL
+                    )
+                """)
+                conn.execute("CREATE INDEX IF NOT EXISTS idx_domain ON atoms(domain)")
+                conn.commit()
+                self._conns[collection] = conn
+            return self._conns[collection]
+
+    def put(self, collection: str, content: str, domain: str = "default",
+            atom_id: Optional[str] = None, meta: Optional[dict] = None) -> str:
+        atom_id = atom_id or str(uuid.uuid4())[:8].upper()
+        now = datetime.now(timezone.utc).isoformat()
+        conn = self._conn(collection)
+        conn.execute(
+            "INSERT OR REPLACE INTO atoms (id, domain, content, meta, created, updated) "
+            "VALUES (?, ?, ?, ?, ?, ?)",
+            (atom_id, domain, content, json.dumps(meta or {}), now, now)
+        )
+        conn.commit()
+        return atom_id
+
+    def get(self, collection: str, atom_id: str) -> Optional[dict]:
+        conn = self._conn(collection)
+        row = conn.execute(
+            "SELECT id, domain, content, meta, created, updated FROM atoms WHERE id = ?",
+            (atom_id,)
+        ).fetchone()
+        if not row:
+            return None
+        return {"id": row[0], "domain": row[1], "content": row[2],
+                "meta": json.loads(row[3]), "created": row[4], "updated": row[5]}
+
+    def list_atoms(self, collection: str, domain: Optional[str] = None, limit: int = 20) -> list[dict]:
+        conn = self._conn(collection)
+        if domain:
+            rows = conn.execute(
+                "SELECT id, domain, content, meta, created FROM atoms WHERE domain = ? "
+                "ORDER BY created DESC LIMIT ?", (domain, limit)
+            ).fetchall()
+        else:
+            rows = conn.execute(
+                "SELECT id, domain, content, meta, created FROM atoms "
+                "ORDER BY created DESC LIMIT ?", (limit,)
+            ).fetchall()
+        return [{"id": r[0], "domain": r[1], "content": r[2],
+                 "meta": json.loads(r[3]), "created": r[4]} for r in rows]
+
+    def search(self, collection: str, query: str, limit: int = 10) -> list[dict]:
+        conn = self._conn(collection)
+        rows = conn.execute(
+            "SELECT id, domain, content, meta, created FROM atoms "
+            "WHERE content LIKE ? ORDER BY created DESC LIMIT ?",
+            (f"%{query}%", limit)
+        ).fetchall()
+        return [{"id": r[0], "domain": r[1], "content": r[2],
+                 "meta": json.loads(r[3]), "created": r[4]} for r in rows]
+
+    def delete(self, collection: str, atom_id: str) -> bool:
+        conn = self._conn(collection)
+        cur = conn.execute("DELETE FROM atoms WHERE id = ?", (atom_id,))
+        conn.commit()
+        return cur.rowcount > 0
+
+    def search_all(self, query: str, limit: int = 10) -> list[dict]:
+        results = []
+        for db_path in sorted(self.root.glob("*.db")):
+            collection = db_path.stem
+            for item in self.search(collection, query, limit):
+                item["collection"] = collection
+                results.append(item)
+        return results[:limit]

willow_mcp-1.0.0/src/willow_mcp/server.py

@@ -0,0 +1,316 @@
+"""
+willow-mcp MCP server — agent-neutral core tools.
+
+Tools:
+  Store (SQLite):  store_put, store_get, store_list, store_search, store_delete, store_search_all
+  Knowledge (PG):  knowledge_search, knowledge_ingest
+  Tasks (PG):      task_submit, task_status, task_list
+
+Auth: SAP/1.0 — app_id required on every call. Set SAP_PGP_FINGERPRINT to pin your key.
+"""
+
+import json
+import os
+import sys
+import uuid
+from typing import Any
+
+import mcp.server.stdio
+import mcp.types as types
+from mcp.server import Server
+
+from .db import Store, get_pg
+
+try:
+    from openclaw_sap_gate import authorized as _sap_authorized
+    _SAP_AVAILABLE = True
+except ImportError:
+    _SAP_AVAILABLE = False
+
+_store = Store()
+_server = Server("willow-mcp")
+_DEFAULT_APP_ID = os.environ.get("WILLOW_APP_ID", "willow-mcp")
+
+
+def _auth(app_id: str) -> tuple[bool, str]:
+    """Check SAP authorization. Returns (ok, error_message)."""
+    if not _SAP_AVAILABLE:
+        return True, ""
+    if not app_id:
+        return False, "app_id is required"
+    if not _sap_authorized(app_id):
+        return False, f"SAP gate denied: '{app_id}' not authorized"
+    return True, ""
+
+
+@_server.list_tools()
+async def list_tools() -> list[types.Tool]:
+    return [
+        types.Tool(
+            name="store_put",
+            description="Write a value to the local SQLite store.",
+            inputSchema={"type": "object", "required": ["app_id", "collection", "content"],
+                         "properties": {
+                             "app_id": {"type": "string"},
+                             "collection": {"type": "string"},
+                             "content": {"type": "string"},
+                             "domain": {"type": "string", "default": "default"},
+                             "id": {"type": "string"},
+                         }},
+        ),
+        types.Tool(
+            name="store_get",
+            description="Read a value from the local SQLite store by ID.",
+            inputSchema={"type": "object", "required": ["app_id", "collection", "id"],
+                         "properties": {
+                             "app_id": {"type": "string"},
+                             "collection": {"type": "string"},
+                             "id": {"type": "string"},
+                         }},
+        ),
+        types.Tool(
+            name="store_list",
+            description="List atoms in a collection.",
+            inputSchema={"type": "object", "required": ["app_id", "collection"],
+                         "properties": {
+                             "app_id": {"type": "string"},
+                             "collection": {"type": "string"},
+                             "domain": {"type": "string"},
+                             "limit": {"type": "integer", "default": 20},
+                         }},
+        ),
+        types.Tool(
+            name="store_search",
+            description="Full-text search within a collection.",
+            inputSchema={"type": "object", "required": ["app_id", "collection", "query"],
+                         "properties": {
+                             "app_id": {"type": "string"},
+                             "collection": {"type": "string"},
+                             "query": {"type": "string"},
+                             "limit": {"type": "integer", "default": 10},
+                         }},
+        ),
+        types.Tool(
+            name="store_delete",
+            description="Delete an atom from the store.",
+            inputSchema={"type": "object", "required": ["app_id", "collection", "id"],
+                         "properties": {
+                             "app_id": {"type": "string"},
+                             "collection": {"type": "string"},
+                             "id": {"type": "string"},
+                         }},
+        ),
+        types.Tool(
+            name="store_search_all",
+            description="Search across all collections.",
+            inputSchema={"type": "object", "required": ["app_id", "query"],
+                         "properties": {
+                             "app_id": {"type": "string"},
+                             "query": {"type": "string"},
+                             "limit": {"type": "integer", "default": 10},
+                         }},
+        ),
+        types.Tool(
+            name="knowledge_ingest",
+            description="Add a knowledge atom to the Postgres knowledge base.",
+            inputSchema={"type": "object", "required": ["app_id", "content"],
+                         "properties": {
+                             "app_id": {"type": "string"},
+                             "content": {"type": "string"},
+                             "domain": {"type": "string", "default": "general"},
+                             "source": {"type": "string"},
+                             "tags": {"type": "array", "items": {"type": "string"}},
+                         }},
+        ),
+        types.Tool(
+            name="knowledge_search",
+            description="Search the Postgres knowledge base.",
+            inputSchema={"type": "object", "required": ["app_id", "query"],
+                         "properties": {
+                             "app_id": {"type": "string"},
+                             "query": {"type": "string"},
+                             "domain": {"type": "string"},
+                             "limit": {"type": "integer", "default": 10},
+                         }},
+        ),
+        types.Tool(
+            name="task_submit",
+            description="Submit a task to the Kart execution queue.",
+            inputSchema={"type": "object", "required": ["app_id", "task"],
+                         "properties": {
+                             "app_id": {"type": "string"},
+                             "task": {"type": "string", "description": "Task text for Kart to execute"},
+                             "agent": {"type": "string", "default": "kart"},
+                         }},
+        ),
+        types.Tool(
+            name="task_status",
+            description="Check status of a submitted task.",
+            inputSchema={"type": "object", "required": ["app_id", "task_id"],
+                         "properties": {
+                             "app_id": {"type": "string"},
+                             "task_id": {"type": "string"},
+                         }},
+        ),
+        types.Tool(
+            name="task_list",
+            description="List pending tasks in the queue.",
+            inputSchema={"type": "object", "required": ["app_id"],
+                         "properties": {
+                             "app_id": {"type": "string"},
+                             "agent": {"type": "string", "default": "kart"},
+                             "limit": {"type": "integer", "default": 10},
+                         }},
+        ),
+    ]
+
+
+@_server.call_tool()
+async def call_tool(name: str, arguments: dict) -> list[types.TextContent]:
+    app_id = arguments.get("app_id", _DEFAULT_APP_ID)
+    ok, err = _auth(app_id)
+    if not ok:
+        return [types.TextContent(type="text", text=json.dumps({"error": err}))]
+
+    try:
+        result = await _dispatch(name, arguments)
+    except Exception as e:
+        result = {"error": str(e)}
+
+    return [types.TextContent(type="text", text=json.dumps(result))]
+
+
+async def _dispatch(name: str, args: dict) -> Any:
+    # ── Store ──────────────────────────────────────────────────────────
+    if name == "store_put":
+        atom_id = _store.put(
+            collection=args["collection"],
+            content=args["content"],
+            domain=args.get("domain", "default"),
+            atom_id=args.get("id"),
+        )
+        return {"id": atom_id, "collection": args["collection"]}
+
+    if name == "store_get":
+        item = _store.get(args["collection"], args["id"])
+        return item or {"error": "not_found"}
+
+    if name == "store_list":
+        return {"items": _store.list_atoms(
+            args["collection"],
+            domain=args.get("domain"),
+            limit=args.get("limit", 20),
+        )}
+
+    if name == "store_search":
+        return {"results": _store.search(
+            args["collection"], args["query"], limit=args.get("limit", 10)
+        )}
+
+    if name == "store_delete":
+        deleted = _store.delete(args["collection"], args["id"])
+        return {"deleted": deleted}
+
+    if name == "store_search_all":
+        return {"results": _store.search_all(args["query"], limit=args.get("limit", 10))}
+
+    # ── Knowledge ──────────────────────────────────────────────────────
+    if name == "knowledge_ingest":
+        pg = get_pg()
+        if not pg:
+            return {"error": "postgres_unavailable"}
+        cur = pg.cursor()
+        kid = str(uuid.uuid4())[:8].upper()
+        cur.execute(
+            "INSERT INTO knowledge (id, content, domain, source, tags) "
+            "VALUES (%s, %s, %s, %s, %s) ON CONFLICT DO NOTHING",
+            (kid, args["content"], args.get("domain", "general"),
+             args.get("source", ""), json.dumps(args.get("tags", [])))
+        )
+        cur.close()
+        return {"id": kid}
+
+    if name == "knowledge_search":
+        pg = get_pg()
+        if not pg:
+            return {"error": "postgres_unavailable"}
+        cur = pg.cursor()
+        query = f"%{args['query']}%"
+        sql = "SELECT id, content, domain, source FROM knowledge WHERE content ILIKE %s"
+        params = [query]
+        if args.get("domain"):
+            sql += " AND domain = %s"
+            params.append(args["domain"])
+        sql += " LIMIT %s"
+        params.append(args.get("limit", 10))
+        cur.execute(sql, params)
+        rows = cur.fetchall()
+        cur.close()
+        return {"results": [{"id": r[0], "content": r[1], "domain": r[2], "source": r[3]}
+                             for r in rows]}
+
+    # ── Task Queue ─────────────────────────────────────────────────────
+    if name == "task_submit":
+        pg = get_pg()
+        if not pg:
+            return {"error": "postgres_unavailable"}
+        task_id = "".join(__import__("random").choices(
+            "ABCDEFGHJKLMNPQRSTUVWXYZ0123456789", k=8))
+        cur = pg.cursor()
+        cur.execute(
+            "INSERT INTO kart_task_queue (task_id, submitted_by, agent, task) "
+            "VALUES (%s, %s, %s, %s)",
+            (task_id, args.get("app_id", "willow-mcp"),
+             args.get("agent", "kart"), args["task"])
+        )
+        cur.close()
+        return {"task_id": task_id, "status": "pending"}
+
+    if name == "task_status":
+        pg = get_pg()
+        if not pg:
+            return {"error": "postgres_unavailable"}
+        cur = pg.cursor()
+        cur.execute(
+            "SELECT task_id, status, result, steps, created_at, completed_at "
+            "FROM kart_task_queue WHERE task_id = %s",
+            (args["task_id"],)
+        )
+        row = cur.fetchone()
+        cur.close()
+        if not row:
+            return {"error": "not_found"}
+        return {"task_id": row[0], "status": row[1], "result": row[2],
+                "steps": row[3], "created_at": str(row[4]), "completed_at": str(row[5])}
+
+    if name == "task_list":
+        pg = get_pg()
+        if not pg:
+            return {"error": "postgres_unavailable"}
+        cur = pg.cursor()
+        cur.execute(
+            "SELECT task_id, task, submitted_by, created_at FROM kart_task_queue "
+            "WHERE status = 'pending' AND agent = %s ORDER BY created_at LIMIT %s",
+            (args.get("agent", "kart"), args.get("limit", 10))
+        )
+        rows = cur.fetchall()
+        cur.close()
+        return {"pending": [{"task_id": r[0], "task": r[1][:80],
+                              "submitted_by": r[2], "created_at": str(r[3])}
+                             for r in rows]}
+
+    return {"error": f"unknown_tool: {name}"}
+
+
+def main():
+    import asyncio
+    asyncio.run(_run())
+
+
+async def _run():
+    async with mcp.server.stdio.stdio_server() as (r, w):
+        await _server.run(r, w, _server.create_initialization_options())
+
+
+if __name__ == "__main__":
+    main()

willow_mcp-1.0.0/tests/test_store.py

@@ -0,0 +1,72 @@
+"""Tests for the SQLite Store."""
+
+import pytest
+from willow_mcp.db import Store
+
+
+@pytest.fixture
+def store(tmp_path):
+    return Store(store_root=str(tmp_path))
+
+
+def test_put_and_get(store):
+    atom_id = store.put("test", "hello world")
+    result = store.get("test", atom_id)
+    assert result is not None
+    assert result["content"] == "hello world"
+    assert result["domain"] == "default"
+
+
+def test_put_custom_id(store):
+    store.put("test", "content", atom_id="MYID")
+    result = store.get("test", "MYID")
+    assert result["content"] == "content"
+
+
+def test_get_missing(store):
+    assert store.get("test", "NOPE") is None
+
+
+def test_list(store):
+    store.put("col", "a")
+    store.put("col", "b")
+    store.put("col", "c")
+    items = store.list_atoms("col", limit=10)
+    assert len(items) == 3
+
+
+def test_list_by_domain(store):
+    store.put("col", "x", domain="alpha")
+    store.put("col", "y", domain="beta")
+    items = store.list_atoms("col", domain="alpha")
+    assert len(items) == 1
+    assert items[0]["content"] == "x"
+
+
+def test_search(store):
+    store.put("col", "the quick brown fox")
+    store.put("col", "lazy dog")
+    results = store.search("col", "quick")
+    assert len(results) == 1
+    assert "quick" in results[0]["content"]
+
+
+def test_delete(store):
+    atom_id = store.put("col", "to delete")
+    assert store.delete("col", atom_id) is True
+    assert store.get("col", atom_id) is None
+
+
+def test_delete_missing(store):
+    assert store.delete("col", "GHOST") is False
+
+
+def test_search_all(store):
+    store.put("col_a", "willow is a system")
+    store.put("col_b", "willow runs on linux")
+    store.put("col_c", "something else")
+    results = store.search_all("willow", limit=10)
+    assert len(results) == 2
+    collections = {r["collection"] for r in results}
+    assert "col_a" in collections
+    assert "col_b" in collections