dirsql-plugin-embeddings 0.1.11__tar.gz → 0.1.12__tar.gz

dirsql_plugin_embeddings-0.1.12/PKG-INFO

@@ -0,0 +1,61 @@
+Metadata-Version: 2.5
+Name: dirsql-plugin-embeddings
+Version: 0.1.12
+Summary: First-party dirsql plugin: semantic search over files.
+Requires-Python: >=3.10
+Requires-Dist: cachetta>=0.7
+Requires-Dist: click>=8
+Requires-Dist: dirsql
+Requires-Dist: model2vec>=0.6
+Requires-Dist: sqlite-vec>=0.1
+Requires-Dist: tqdm>=4
+Description-Content-Type: text/markdown
+
+# dirsql-plugin-embeddings
+
+A first-party [`dirsql`](https://github.com/thekevinscott/dirsql) plugin for
+semantic search over files.
+
+Installing the plugin loads the
+[`sqlite-vec`](https://github.com/asg017/sqlite-vec) extension (for
+`vec_distance_cosine()` and friends) and declares an `embed()` SQL scalar
+function that turns TEXT or BLOB values into embedding vectors:
+
+```sh
+uvx --with dirsql-plugin-embeddings dirsql "
+  SELECT path
+  FROM (SELECT path, embed(content ->> 'abstract') AS emb
+        FROM 'arxiv-firehose/data/**/metadata.json')
+  ORDER BY vec_distance_cosine(emb, embed('local private models'))
+  LIMIT 10"
+```
+
+`embed()` is inert until a query calls it: no worker process is spawned and no
+model is loaded for queries that never use it. On the first call, dirsql
+spawns the plugin's worker process (`dirsql-plugin-embeddings worker`), which
+serves every call of the invocation over stdin/stdout.
+
+## Model
+
+Embeddings come from [model2vec](https://github.com/MinishLab/model2vec)
+(static embeddings — numpy + tokenizers, no torch), defaulting to
+[`minishlab/potion-retrieval-32M`](https://huggingface.co/minishlab/potion-retrieval-32M).
+The model downloads to the standard Hugging Face cache on the first ever run,
+with progress on stderr when stderr is a TTY.
+
+An optional second argument overrides the model per call — the id must be
+model2vec-loadable (sentence-transformers/torch models are out of scope):
+
+```sql
+SELECT embed('some text', 'minishlab/potion-base-8M')
+```
+
+## Vector cache
+
+Computed vectors are cached at `~/.cache/dirsql/embeddings/` (or
+`$XDG_CACHE_HOME/dirsql/embeddings/` when `XDG_CACHE_HOME` is set), keyed by
+the SHA-256 of the value bytes plus the model identifier — changing either
+recomputes; switching models never serves stale vectors. There is no
+eviction: **the directory is safe to wipe at any time**; the only cost is
+re-embedding. The cache never lives inside a queried tree — the worker
+receives values, not paths, and writes nothing anywhere else.

dirsql_plugin_embeddings-0.1.12/README.md

@@ -0,0 +1,48 @@
+# dirsql-plugin-embeddings
+
+A first-party [`dirsql`](https://github.com/thekevinscott/dirsql) plugin for
+semantic search over files.
+
+Installing the plugin loads the
+[`sqlite-vec`](https://github.com/asg017/sqlite-vec) extension (for
+`vec_distance_cosine()` and friends) and declares an `embed()` SQL scalar
+function that turns TEXT or BLOB values into embedding vectors:
+
+```sh
+uvx --with dirsql-plugin-embeddings dirsql "
+  SELECT path
+  FROM (SELECT path, embed(content ->> 'abstract') AS emb
+        FROM 'arxiv-firehose/data/**/metadata.json')
+  ORDER BY vec_distance_cosine(emb, embed('local private models'))
+  LIMIT 10"
+```
+
+`embed()` is inert until a query calls it: no worker process is spawned and no
+model is loaded for queries that never use it. On the first call, dirsql
+spawns the plugin's worker process (`dirsql-plugin-embeddings worker`), which
+serves every call of the invocation over stdin/stdout.
+
+## Model
+
+Embeddings come from [model2vec](https://github.com/MinishLab/model2vec)
+(static embeddings — numpy + tokenizers, no torch), defaulting to
+[`minishlab/potion-retrieval-32M`](https://huggingface.co/minishlab/potion-retrieval-32M).
+The model downloads to the standard Hugging Face cache on the first ever run,
+with progress on stderr when stderr is a TTY.
+
+An optional second argument overrides the model per call — the id must be
+model2vec-loadable (sentence-transformers/torch models are out of scope):
+
+```sql
+SELECT embed('some text', 'minishlab/potion-base-8M')
+```
+
+## Vector cache
+
+Computed vectors are cached at `~/.cache/dirsql/embeddings/` (or
+`$XDG_CACHE_HOME/dirsql/embeddings/` when `XDG_CACHE_HOME` is set), keyed by
+the SHA-256 of the value bytes plus the model identifier — changing either
+recomputes; switching models never serves stale vectors. There is no
+eviction: **the directory is safe to wipe at any time**; the only cost is
+re-embedding. The cache never lives inside a queried tree — the worker
+receives values, not paths, and writes nothing anywhere else.

dirsql_plugin_embeddings-0.1.12/changelog.d/2026-08-10-embed-worker.md

@@ -0,0 +1,14 @@
+**Added** the `dirsql-plugin-embeddings worker` subcommand: a persistent
+stdin/stdout process serving `embed()` requests as newline-delimited JSON
+(`{"call": [value, model_id?]}` → `{"ok": [floats...]}` / `{"err": "message"}`).
+Values are SQL TEXT (JSON strings) or BLOB (`{"$bytes": "<base64>"}`, decoded
+as utf-8); embeddings come from model2vec (default
+`minishlab/potion-retrieval-32M`, loaded lazily on the first request, one load
+per process; an optional second argument overrides the model id). Vectors are
+cached on disk via cachetta at `~/.cache/dirsql/embeddings/` (respects
+`XDG_CACHE_HOME`; safe to wipe — the only cost is re-embedding), keyed by the
+SHA-256 of the value bytes plus the model identifier. Progress is reported on
+stderr only when stderr is a TTY. The packaged `dirsql.toml` now declares the
+`embed` SQL function via `[[dirsql.function]]` (name `embed`, arities 1–2,
+deterministic, 600s per-call timeout) alongside the existing sqlite-vec
+`[[dirsql.extension]]` entry.

dirsql_plugin_embeddings-0.1.12/changelog.d/2026-08-11-one-liner-cli.md

@@ -0,0 +1,14 @@
+**Added** the one-liner search CLI as the default command:
+`dirsql-plugin-embeddings '<glob>' '<query>' [-k/--limit N] [--model ID]`.
+The corpus glob is a required first positional (no default corpus), the query
+text the second; `-k`/`--limit` (default 10) is exactly the SQL `LIMIT`, and
+`--model` templates the model id as `embed()`'s second argument in the
+generated SQL. The command builds the canonical search SQL (an `embed()`
+subquery over the glob's rows, `vec_distance_cosine` against
+`embed('<query>')`, `ORDER BY distance LIMIT k`), runs it via the dirsql
+Python SDK (now a declared dependency; needs dirsql >= 0.4.17, the first
+release with `[[dirsql.function]]`) with the packaged
+config fragment, and prints ranked `path<TAB>distance` lines. Query text,
+model id, and glob are SQL-escaped. The `worker` subcommand is unchanged;
+there is no explicit `search` spelling — a literal `search` first token is a
+corpus glob.

dirsql_plugin_embeddings-0.1.12/e2e-attestations/claude-804-embed-worker.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run --with-editable ../../packages/python python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1786455708,
+  "exit_code": 0,
+  "commit": "9d8bf1c91b82cb4f6648789e0d4df9b1aa932921",
+  "branch": "claude/804-embed-worker"
+}

dirsql_plugin_embeddings-0.1.12/e2e-attestations/claude-805-one-liner.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run --with-editable ../../packages/python python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1786459020,
+  "exit_code": 0,
+  "commit": "1bd863d143acbb821b3e6e594e1e1688a5e1178d",
+  "branch": "claude/805-one-liner"
+}

{dirsql_plugin_embeddings-0.1.11 → dirsql_plugin_embeddings-0.1.12}/pyproject.toml

@@ -3,12 +3,10 @@ requires = ["hatchling", "hatch-vcs"]
 build-backend = "hatchling.build"
 
 [project]
-# First-party dirsql plugin, published independently to PyPI. Mid-rebuild:
-# today it only loads sqlite-vec; the embed() SQL function surface is landing
-# in follow-up slices.
+# First-party dirsql plugin, published independently to PyPI.
 name = "dirsql-plugin-embeddings"
 dynamic = ["version"]
-description = "First-party dirsql plugin: semantic search over files (rebuild in progress)."
+description = "First-party dirsql plugin: semantic search over files."
 readme = "README.md"
 requires-python = ">=3.10"
 # sqlite-vec is a runtime dependency, not a docs suggestion: the shipped
@@ -16,7 +14,29 @@ requires-python = ">=3.10"
 # only resolve when the package is installed. Declaring it here makes the
 # quickstart (`uvx --with dirsql-plugin-embeddings dirsql`) work without a
 # separate `--with sqlite-vec`.
-dependencies = ["sqlite-vec>=0.1"]
+#
+# model2vec (NOT sentence-transformers/torch) is the inference stack: static
+# embeddings whose runtime deps are numpy + tokenizers, viable in uvx
+# ephemeral envs. cachetta is the vector cache; tqdm the stderr progress UI.
+#
+# dirsql is the SDK the one-liner search command runs its generated SQL
+# through. Functionally it needs >= 0.4.17 (the first release with the core
+# [[dirsql.function]] mechanism), but the requirement stays unversioned: the
+# in-repo editable SDK builds under the stale on-disk version literal (the
+# release pipeline rewrites it at publish time), so any floor would make the
+# local e2e overlay (`uv run --with-editable ../../packages/python`)
+# unresolvable. Fresh installs resolve the latest release regardless.
+dependencies = [
+    "dirsql",
+    "sqlite-vec>=0.1",
+    "model2vec>=0.6",
+    "cachetta>=0.7",
+    "tqdm>=4",
+    "click>=8",
+]
+
+[project.scripts]
+dirsql-plugin-embeddings = "dirsql_plugin_embeddings.cli.main:main"
 
 [tool.hatch.version]
 source = "vcs"
@@ -47,7 +67,12 @@ git_describe_command = ["git", "describe", "--dirty", "--tags", "--long", "--mat
 embeddings = "dirsql_plugin_embeddings"
 
 [dependency-groups]
-dev = ["pytest>=8", "pytest-cov>=5", "pytest-describe>=2"]
+dev = [
+    "pytest>=8",
+    "pytest-cov>=5",
+    "pytest-describe>=2",
+    "tomli>=2; python_version < '3.11'",
+]
 
 [tool.hatch.build]
 exclude = ["**/*_test.py"]

dirsql_plugin_embeddings-0.1.12/src/dirsql_plugin_embeddings/cli/main.py

@@ -0,0 +1,37 @@
+import click
+
+from .search import search
+from .worker import worker
+
+
+class DefaultCommandGroup(click.Group):
+    """Route non-`worker` invocations to the hidden search command.
+
+    Bare positionals are the plugin's only search interface
+    (`dirsql-plugin-embeddings '<glob>' '<query>'`): a first token counts as
+    a subcommand only when it names a *visible* command, so a literal
+    'search' first token is a corpus glob, not a spelling of the command.
+    """
+
+    def parse_args(self, ctx, args):
+        visible = [
+            name
+            for name, command in self.commands.items()
+            if not command.hidden
+        ]
+        if not args or (args[0] != "--help" and args[0] not in visible):
+            args = [search.name, *args]
+        return super().parse_args(ctx, args)
+
+
+@click.group(cls=DefaultCommandGroup)
+def main():
+    """dirsql embeddings plugin.
+
+    Bare arguments run the semantic search:
+    dirsql-plugin-embeddings '<glob>' '<query>' [-k N] [--model ID]
+    """
+
+
+main.add_command(worker, name="worker")
+main.add_command(search, name="search")

dirsql_plugin_embeddings-0.1.12/src/dirsql_plugin_embeddings/cli/search.py

@@ -0,0 +1,26 @@
+import click
+
+from ..search.run import run_search
+
+
+@click.command(hidden=True)
+@click.argument("glob")
+@click.argument("query")
+@click.option(
+    "-k",
+    "--limit",
+    "limit",
+    type=int,
+    default=10,
+    show_default=True,
+    help="Maximum results; exactly the SQL LIMIT.",
+)
+@click.option(
+    "--model",
+    default=None,
+    help="model2vec model id, templated as embed()'s second argument.",
+)
+def search(glob, query, limit, model):
+    """Rank files matching GLOB by semantic similarity to QUERY."""
+    for line in run_search(glob, query, limit, model):
+        click.echo(line)

dirsql_plugin_embeddings-0.1.12/src/dirsql_plugin_embeddings/cli/worker.py

@@ -0,0 +1,13 @@
+import sys
+
+import click
+
+from ..embedding.progress import configure
+from ..embedding.worker import Worker
+
+
+@click.command()
+def worker():
+    """Serve embed() requests as newline-delimited JSON on stdin/stdout."""
+    configure()
+    Worker().serve(sys.stdin, sys.stdout)

dirsql_plugin_embeddings-0.1.12/src/dirsql_plugin_embeddings/dirsql.toml

@@ -0,0 +1,16 @@
+# Fragment shipped by the dirsql-plugin-embeddings plugin.
+# Discovered via the package's [project.entry-points.dirsql] declaration and
+# injected by the launcher as an ordinary -c flag ("installed = active").
+[[dirsql.extension]]
+path = "sqlite_vec"
+entrypoint = "sqlite3_vec_init"
+
+# The embed() SQL scalar function, served by the plugin's worker process over
+# newline-delimited JSON on stdin/stdout. Inert until a query calls it. The
+# generous timeout absorbs the first call's model download.
+[[dirsql.function]]
+name = "embed"
+args = [1, 2]
+command = "dirsql-plugin-embeddings worker"
+deterministic = true
+timeout = "600s"

dirsql_plugin_embeddings-0.1.12/src/dirsql_plugin_embeddings/embedding/cache.py

@@ -0,0 +1,19 @@
+import os
+from datetime import timedelta
+from pathlib import Path
+
+from cachetta import Cachetta
+
+# No eviction: entries stay until the user wipes the directory (documented as
+# safe -- the only cost is re-embedding).
+NO_EVICTION = timedelta(days=365000)
+
+
+def cache_dir():
+    xdg = os.environ.get("XDG_CACHE_HOME", "")
+    base = Path(xdg) if xdg else Path.home() / ".cache"
+    return base / "dirsql" / "embeddings"
+
+
+def make_cache():
+    return Cachetta(path=cache_dir(), hashed=True, duration=NO_EVICTION)

dirsql_plugin_embeddings-0.1.12/src/dirsql_plugin_embeddings/embedding/model.py

@@ -0,0 +1,15 @@
+DEFAULT_MODEL_ID = "minishlab/potion-retrieval-32M"
+
+
+def load_model(model_id):
+    from model2vec import StaticModel
+
+    return StaticModel.from_pretrained(model_id)
+
+
+def model_identifier(model_id, model):
+    config = getattr(model, "config", None) or {}
+    version = config.get("model2vec_version")
+    if version:
+        return f"{model_id}@{version}"
+    return model_id

dirsql_plugin_embeddings-0.1.12/src/dirsql_plugin_embeddings/embedding/progress.py

@@ -0,0 +1,13 @@
+import os
+import sys
+
+
+def stderr_is_tty():
+    return sys.stderr.isatty()
+
+
+def configure():
+    # Hugging Face hub download bars honor this variable; setdefault keeps an
+    # explicit user choice in force.
+    if not stderr_is_tty():
+        os.environ.setdefault("HF_HUB_DISABLE_PROGRESS_BARS", "1")

dirsql_plugin_embeddings-0.1.12/src/dirsql_plugin_embeddings/embedding/values.py

@@ -0,0 +1,28 @@
+import base64
+import binascii
+
+
+class ProtocolError(ValueError):
+    """A request value that does not follow the worker protocol."""
+
+
+def decode_value(value):
+    if value is None:
+        return None
+    if isinstance(value, str):
+        return value
+    if isinstance(value, dict) and set(value) == {"$bytes"}:
+        encoded = value["$bytes"]
+        if not isinstance(encoded, str):
+            raise ProtocolError('the "$bytes" value must be a base64 string')
+        try:
+            raw = base64.b64decode(encoded, validate=True)
+        except binascii.Error as error:
+            raise ProtocolError(f'invalid base64 in "$bytes": {error}') from error
+        try:
+            return raw.decode("utf-8")
+        except UnicodeDecodeError as error:
+            raise ProtocolError(f"BLOB is not valid utf-8 text: {error}") from error
+    raise ProtocolError(
+        f"embed() accepts TEXT or BLOB values, got {type(value).__name__}"
+    )

dirsql_plugin_embeddings-0.1.12/src/dirsql_plugin_embeddings/embedding/worker.py

@@ -0,0 +1,71 @@
+import json
+from hashlib import sha256
+
+from . import model
+from .cache import make_cache
+from .progress import stderr_is_tty
+from .values import ProtocolError, decode_value
+
+MALFORMED_SHAPE = (
+    'malformed request: expected {"call": [value, model_id?]} on one line'
+)
+MALFORMED_ARITY = 'malformed request: "call" must carry 1 or 2 arguments'
+MALFORMED_MODEL_ID = "the model id must be TEXT"
+
+
+class Worker:
+    def __init__(self):
+        self._models = {}
+        self._cache = make_cache()
+        self._compute_cached = self._cache.wrap(self._compute)
+        self._pending = None
+
+    def _model(self, model_id):
+        if model_id not in self._models:
+            self._models[model_id] = model.load_model(model_id)
+        return self._models[model_id]
+
+    def _compute(self, digest, identifier):
+        text, loaded = self._pending
+        (vector,) = loaded.encode([text], show_progress_bar=stderr_is_tty())
+        return [float(component) for component in vector]
+
+    def embed(self, text, model_id):
+        loaded = self._model(model_id)
+        identifier = model.model_identifier(model_id, loaded)
+        digest = sha256(text.encode("utf-8")).hexdigest()
+        self._pending = (text, loaded)
+        return self._compute_cached(digest, identifier)
+
+    def handle(self, line):
+        try:
+            request = json.loads(line)
+        except json.JSONDecodeError as error:
+            return {"err": f"malformed request: invalid JSON: {error}"}
+        if not isinstance(request, dict) or "call" not in request:
+            return {"err": MALFORMED_SHAPE}
+        call = request["call"]
+        if not isinstance(call, list) or len(call) not in (1, 2):
+            return {"err": MALFORMED_ARITY}
+        value, *rest = call
+        try:
+            text = decode_value(value)
+        except ProtocolError as error:
+            return {"err": str(error)}
+        if text is None:
+            return {"ok": None}
+        (model_id,) = rest or [model.DEFAULT_MODEL_ID]
+        if not isinstance(model_id, str):
+            return {"err": MALFORMED_MODEL_ID}
+        try:
+            return {"ok": self.embed(text, model_id)}
+        except Exception as error:
+            return {"err": f"embed({model_id!r}) failed: {error}"}
+
+    def serve(self, stdin, stdout):
+        for line in stdin:
+            if not line.strip():
+                continue
+            response = self.handle(line)
+            stdout.write(json.dumps(response, separators=(",", ":")) + "\n")
+            stdout.flush()

dirsql_plugin_embeddings-0.1.12/src/dirsql_plugin_embeddings/search/output.py

@@ -0,0 +1,2 @@
+def format_rows(rows):
+    return [f"{row['path']}\t{row['distance']:.6f}" for row in rows]

dirsql_plugin_embeddings-0.1.12/src/dirsql_plugin_embeddings/search/run.py

@@ -0,0 +1,20 @@
+import asyncio
+from importlib import resources
+
+import dirsql
+
+from .output import format_rows
+from .sql import build_search_sql
+
+
+def config_fragment():
+    return str(resources.files("dirsql_plugin_embeddings").joinpath("dirsql.toml"))
+
+
+async def _query(sql):
+    return await dirsql.DirSQL(config=config_fragment()).query(sql)
+
+
+def run_search(glob, query, limit, model=None):
+    rows = asyncio.run(_query(build_search_sql(glob, query, limit, model)))
+    return format_rows(rows)

dirsql_plugin_embeddings-0.1.12/src/dirsql_plugin_embeddings/search/sql.py

@@ -0,0 +1,32 @@
+PATH_PREFIXES = ("./", "../", "/", "~/")
+
+
+def quote(text):
+    escaped = text.replace("'", "''")
+    return f"'{escaped}'"
+
+
+def normalize_glob(glob):
+    # The core only rescues path-shaped missing tables (./, ../, /, ~/); a
+    # bare relative glob like '**/*.md' would error with a "did you mean
+    # './...'" hint. Here GLOB is unambiguously a corpus glob, so spare the
+    # user the round trip.
+    if glob.startswith(PATH_PREFIXES):
+        return glob
+    return f"./{glob}"
+
+
+def embed_call(argument, model):
+    if model is None:
+        return f"embed({argument})"
+    return f"embed({argument}, {quote(model)})"
+
+
+def build_search_sql(glob, query, limit, model=None):
+    outer = embed_call(quote(query), model)
+    inner = embed_call("content", model)
+    return (
+        f"SELECT path, vec_distance_cosine(emb, {outer}) AS distance"
+        f" FROM (SELECT path, {inner} AS emb FROM {quote(normalize_glob(glob))})"
+        f" ORDER BY distance LIMIT {int(limit):d}"
+    )

dirsql_plugin_embeddings-0.1.12/tests/conftest.py

@@ -0,0 +1,115 @@
+"""Shared fixtures for the integration and e2e tiers.
+
+``make_model`` builds a real model2vec model on disk: a three-token WordLevel
+vocabulary with hand-picked vectors, so embeddings are deterministic and no
+network or Hugging Face download is involved. The worker loads it through the
+ordinary model-override argument (`{"call": [text, "<path>"]}`), exercising
+the exact code path a hub model id takes.
+
+``worker_process`` spawns the real worker subcommand as a subprocess over real
+pipes, with ``XDG_CACHE_HOME`` pointed at a per-test temp dir so the vector
+cache is isolated and its location is observable.
+"""
+
+import json
+import os
+import subprocess
+import sys
+
+import numpy as np
+import pytest
+from model2vec import StaticModel
+from tokenizers import Tokenizer
+from tokenizers.models import WordLevel
+from tokenizers.pre_tokenizers import Whitespace
+
+VOCAB = {"[UNK]": 0, "hello": 1, "world": 2}
+
+WORKER_ARGV = [
+    sys.executable,
+    "-c",
+    "import sys; from dirsql_plugin_embeddings.cli.main import main; sys.exit(main())",
+    "worker",
+]
+
+
+def build_model(directory, rows):
+    tokenizer = Tokenizer(WordLevel(VOCAB, unk_token="[UNK]"))
+    tokenizer.pre_tokenizer = Whitespace()
+    vectors = np.array(rows, dtype=np.float32)
+    model = StaticModel(vectors, tokenizer, config={"normalize": False})
+    model.save_pretrained(directory)
+    return str(directory)
+
+
+@pytest.fixture(scope="session")
+def tiny_model(tmp_path_factory):
+    # [UNK] -> [0, 0], hello -> [1, 0], world -> [0, 1].
+    return build_model(
+        tmp_path_factory.mktemp("model-a"),
+        [[0.0, 0.0], [1.0, 0.0], [0.0, 1.0]],
+    )
+
+
+@pytest.fixture(scope="session")
+def other_model(tmp_path_factory):
+    # Same vocabulary, different vectors: hello -> [0, 2].
+    return build_model(
+        tmp_path_factory.mktemp("model-b"),
+        [[0.0, 0.0], [0.0, 2.0], [2.0, 0.0]],
+    )
+
+
+class WorkerProcess:
+    def __init__(self, argv, cache_home, cwd=None):
+        self.process = subprocess.Popen(
+            argv,
+            stdin=subprocess.PIPE,
+            stdout=subprocess.PIPE,
+            stderr=subprocess.PIPE,
+            text=True,
+            cwd=cwd,
+            env={**os.environ, "XDG_CACHE_HOME": str(cache_home)},
+        )
+
+    def send_line(self, line):
+        self.process.stdin.write(line + "\n")
+        self.process.stdin.flush()
+        response = self.process.stdout.readline()
+        assert response, (
+            f"worker produced no response line; exited with"
+            f" {self.process.poll()}, stderr: {self.process.stderr.read()!r}"
+        )
+        return json.loads(response)
+
+    def request(self, *call):
+        return self.send_line(json.dumps({"call": list(call)}))
+
+    def close(self):
+        self.process.stdin.close()
+        code = self.process.wait(timeout=30)
+        stderr = self.process.stderr.read()
+        self.process.stdout.close()
+        self.process.stderr.close()
+        return code, stderr
+
+
+@pytest.fixture
+def cache_home(tmp_path):
+    return tmp_path / "xdg-cache"
+
+
+@pytest.fixture
+def spawn_worker(cache_home):
+    workers = []
+
+    def spawn(argv=WORKER_ARGV, cwd=None):
+        worker = WorkerProcess(argv, cache_home, cwd=cwd)
+        workers.append(worker)
+        return worker
+
+    yield spawn
+    for worker in workers:
+        if worker.process.poll() is None:
+            worker.process.kill()
+        worker.process.wait()

dirsql_plugin_embeddings-0.1.11/PKG-INFO

@@ -1,28 +0,0 @@
-Metadata-Version: 2.4
-Name: dirsql-plugin-embeddings
-Version: 0.1.11
-Summary: First-party dirsql plugin: semantic search over files (rebuild in progress).
-Requires-Python: >=3.10
-Requires-Dist: sqlite-vec>=0.1
-Description-Content-Type: text/markdown
-
-# dirsql-plugin-embeddings
-
-A first-party [`dirsql`](https://github.com/thekevinscott/dirsql) plugin for
-semantic search over files.
-
-**Rebuild in progress**
-([#800](https://github.com/thekevinscott/dirsql/issues/800)): the previous
-surface — a declared `documents` table built eagerly over the working
-directory, per-file `on-file` embedding hooks, a `pre-query` hook, and
-`DIRSQL_EMBEDDINGS_*` endpoint configuration — has been removed. The plugin is
-being rebuilt around a plugin-provided `embed()` SQL function that is inert
-until a query calls it.
-
-Today, installing the plugin loads the
-[`sqlite-vec`](https://github.com/asg017/sqlite-vec) extension (for
-`vec_distance_cosine()` and friends) and nothing else.
-
-```sh
-uvx --with dirsql-plugin-embeddings dirsql "SELECT vec_distance_cosine('[1, 0]', '[0, 1]') AS d"
-```

dirsql_plugin_embeddings-0.1.11/README.md

@@ -1,20 +0,0 @@
-# dirsql-plugin-embeddings
-
-A first-party [`dirsql`](https://github.com/thekevinscott/dirsql) plugin for
-semantic search over files.
-
-**Rebuild in progress**
-([#800](https://github.com/thekevinscott/dirsql/issues/800)): the previous
-surface — a declared `documents` table built eagerly over the working
-directory, per-file `on-file` embedding hooks, a `pre-query` hook, and
-`DIRSQL_EMBEDDINGS_*` endpoint configuration — has been removed. The plugin is
-being rebuilt around a plugin-provided `embed()` SQL function that is inert
-until a query calls it.
-
-Today, installing the plugin loads the
-[`sqlite-vec`](https://github.com/asg017/sqlite-vec) extension (for
-`vec_distance_cosine()` and friends) and nothing else.
-
-```sh
-uvx --with dirsql-plugin-embeddings dirsql "SELECT vec_distance_cosine('[1, 0]', '[0, 1]') AS d"
-```

dirsql_plugin_embeddings-0.1.11/src/dirsql_plugin_embeddings/dirsql.toml

@@ -1,6 +0,0 @@
-# Fragment shipped by the dirsql-plugin-embeddings plugin.
-# Discovered via the package's [project.entry-points.dirsql] declaration and
-# injected by the launcher as an ordinary -c flag ("installed = active").
-[[dirsql.extension]]
-path = "sqlite_vec"
-entrypoint = "sqlite3_vec_init"