dirsql-plugin-embeddings 0.1.17__tar.gz → 0.1.18__tar.gz

{dirsql_plugin_embeddings-0.1.17 → dirsql_plugin_embeddings-0.1.18}/.gitignore

@@ -57,5 +57,7 @@ docs/blob-report/
 docs/.playwright/
 actionlint
 
-# cargo-mutants run output (never commit)
+# cargo-mutants run output (never commit). The tool rotates the previous
+# run's directory to `.old` on every re-run, so both forms need ignoring.
 mutants.out/
+mutants.out.old/

{dirsql_plugin_embeddings-0.1.17 → dirsql_plugin_embeddings-0.1.18}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: dirsql-plugin-embeddings
-Version: 0.1.17
+Version: 0.1.18
 Summary: First-party dirsql plugin: semantic search over files.
 Requires-Python: >=3.10
 Requires-Dist: cachetta>=0.7

dirsql_plugin_embeddings-0.1.18/changelog.d/2026-09-04-report-cache-hits.md

@@ -0,0 +1,3 @@
+**Added**
+
+- **The worker now tells dirsql which embeddings cost nothing.** Every `ok` response carries `"meta": {"cached": <bool>}`, so the progress line can split its worker-call count — `dirsql: ran 41231 worker calls in 2m41s (38104 cached)` — instead of reporting one undifferentiated total for a run that was mostly disk reads. `cachetta`'s wrapper returns a hit and a miss identically, so the flag is recovered from whether the wrapped compute actually ran. (#1034)

dirsql_plugin_embeddings-0.1.18/e2e-attestations/claude-tackle-1034-plugin-flag.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run --with-editable ../../packages/python python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1788558384,
+  "exit_code": 0,
+  "commit": "fc3ee82adb022a9b6da85687695ca752dd178f03",
+  "branch": "claude/tackle-1034-plugin-flag"
+}

dirsql_plugin_embeddings-0.1.18/migrations.d/2026-09-04-report-cache-hits.md

@@ -0,0 +1,39 @@
+### dirsql-plugin-embeddings: `ok` responses now carry cache metadata
+
+#### Summary
+
+The worker's success responses gain an optional `"meta"` object:
+`{"ok": [floats...], "meta": {"cached": true|false}}`. Nothing is removed and
+no signature a user calls changes — the plugin exports no Python API, and its
+CLI arguments, exit codes and vectors are all untouched. The one observable
+difference is the extra key on the wire, and the progress line dirsql draws
+from it.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- A worker `ok` line previously read `{"ok": [1.0, 0.0]}` and now reads
+  `{"ok": [1.0, 0.0], "meta": {"cached": false}}`. dirsql ignores unknown keys,
+  so this is additive for it; a third party parsing worker output with an
+  exact-equality check on the whole object will see a mismatch and should
+  compare `response["ok"]` instead.
+- `{"ok": null}` for a NULL value is unchanged — no compute is attempted, so
+  there is no cache state to report.
+- With the plugin installed, `dirsql` runs that hit the on-disk cache now show
+  the split in the progress line (`ran 41231 worker calls in 2m41s
+  (38104 cached)`). A run with no hits looks exactly as it did before.
+
+#### Verification
+
+```bash
+printf '{"call": ["hello"]}\n{"call": ["hello"]}\n' \
+  | uvx --from dirsql-plugin-embeddings dirsql-plugin-embeddings worker
+# expected: first line "cached":false, second line "cached":true
+```

{dirsql_plugin_embeddings-0.1.17 → dirsql_plugin_embeddings-0.1.18}/src/dirsql_plugin_embeddings/embedding/worker.py

@@ -18,6 +18,7 @@ class Worker:
         self._cache = make_cache()
         self._compute_cached = self._cache.wrap(self._compute)
         self._pending = None
+        self._computed = False
 
     def _model(self, model_id):
         if model_id not in self._models:
@@ -25,6 +26,10 @@ class Worker:
         return self._models[model_id]
 
     def _compute(self, digest, identifier):
+        # cachetta's wrapper returns a hit and a miss identically, so the only
+        # place a miss is observable is here: _compute runs on a miss and never
+        # on a hit. embed() clears the flag and reads it back afterwards.
+        self._computed = True
         text, loaded = self._pending
         # No progress bar: the protocol embeds one value per round trip, so a
         # per-call bar can only ever say 1/1. The model *download* bar, which
@@ -33,11 +38,21 @@ class Worker:
         return [float(component) for component in vector]
 
     def embed(self, text, model_id):
+        """Return the vector for ``text``, and whether the cache served it."""
         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)
+        self._computed = False
+        vector = self._compute_cached(digest, identifier)
+        return vector, not self._computed
+
+    def _embed_response(self, text, model_id):
+        try:
+            vector, cached = self.embed(text, model_id)
+        except Exception as error:
+            return {"err": f"embed({model_id!r}) failed: {error}"}
+        return {"ok": vector, "meta": {"cached": cached}}
 
     def handle(self, line):
         try:
@@ -59,10 +74,7 @@ class Worker:
         (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}"}
+        return self._embed_response(text, model_id)
 
     def serve(self, stdin, stdout):
         for line in stdin:

{dirsql_plugin_embeddings-0.1.17 → dirsql_plugin_embeddings-0.1.18}/testing-conventions.toml

@@ -2,6 +2,9 @@
 # package. Mirrors internals/checks: python coverage floor 100 + branch, zero
 # exemptions, and deliberately no `[e2e] extra_scope` -- this package compiles
 # none of packages/rust/src, so a core change never stales its attestation.
+[python]
+one_function_per_file = { max_lines = 24 }
+
 [python.coverage]
 fail_under = 100
 branch = true