dirsql 0.4.83__tar.gz → 0.4.85__tar.gz

{dirsql-0.4.83 → dirsql-0.4.85}/Cargo.lock

@@ -552,7 +552,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.83"
+version = "0.4.85"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -602,7 +602,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.83"
+version = "0.4.85"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.83 → dirsql-0.4.85}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.83
+Version: 0.4.85
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index

{dirsql-0.4.83 → dirsql-0.4.85}/dirsql/_async.py

@@ -2,6 +2,7 @@
 
 import asyncio
 import os
+import weakref
 
 from dirsql._dirsql import DirSQL as _RustDirSQL
 from dirsql.resolve_configs_extension_specs import resolve_configs_extension_specs
@@ -9,13 +10,18 @@ from dirsql.resolve_extension import resolve_extension_path
 
 
 class _WatchStream:
-    """Async iterator that polls for file events."""
+    """Async iterator of file events.
+
+    Every stream on one ``DirSQL`` receives every event observed after it
+    was created: one shared poll fills the buffer of each live stream.
+    """
 
     def __init__(self, owner):
         self._owner = owner
         self._db = None
         self._started = False
         self._buffer = []
+        owner._watch_streams.add(self)
 
     def __aiter__(self):
         return self
@@ -29,14 +35,22 @@ class _WatchStream:
             await asyncio.to_thread(db._start_watcher)
             self._started = True
 
+        owner = self._owner
+        while not self._buffer:
+            poll = owner._watch_poll
+            if poll is None or poll.done():
+                poll = owner._watch_poll = asyncio.ensure_future(self._poll())
+            # Shielded so a cancelled consumer cannot drop a batch that the
+            # other streams are still waiting on.
+            await asyncio.shield(poll)
+        return self._buffer.pop(0)
+
+    async def _poll(self):
         db = self._db
         assert db is not None
-        while True:
-            if self._buffer:
-                return self._buffer.pop(0)
-            events = await asyncio.to_thread(db._poll_events, 200)
-            if events:
-                self._buffer.extend(events)
+        events = await asyncio.to_thread(db._poll_events, 200)
+        for stream in list(self._owner._watch_streams):
+            stream._buffer.extend(events)
 
 
 class DirSQL:
@@ -107,6 +121,8 @@ class DirSQL:
         self._db = None
         self._ready_event = asyncio.Event()
         self._init_error = None
+        self._watch_streams = weakref.WeakSet()
+        self._watch_poll = None
         self._task = asyncio.ensure_future(self._init_bg())
 
     async def _init_bg(self):
@@ -218,5 +234,9 @@ class DirSQL:
         before an explicit ``await db.ready()`` waits for the background scan
         (and surfaces any initialization error) instead of failing on a
         still-``None`` ``_db``.
+
+        Each call returns an independent stream, and every stream receives
+        every event observed after it was created, so several consumers
+        (one per client, say) can share one instance.
         """
         return _WatchStream(self)

{dirsql-0.4.83/packages/rust → dirsql-0.4.85}/docs/reference/config.md

@@ -274,6 +274,10 @@ So `glob = "projects/*/*.jsonl"` in `~/.claude/.dirsql.toml` indexes
 writes `glob = "~/.claude/projects/*/*.jsonl"`. A table's `path` and `dir`
 columns, `{root}`, and `ignore` are all relative to its anchor.
 
+A table whose glob matches no files prints
+`dirsql: table 'sessions': glob 'projects/*/*.jsonl' matched no files under <anchor>`
+to stderr; the exit code is unchanged. Path-tables and programmatic tables do not warn.
+
 ### Batch `ddl`
 
 `ddl` is handed to SQLite whole, so a table declaration is not limited to one

{dirsql-0.4.83/packages/rust → dirsql-0.4.85}/docs/reference/http-api.md

@@ -112,4 +112,4 @@ Row values serialize as in [`POST /query`](#value-serialization).
 |---|---|
 | `200` | Stream opened (`text/event-stream`). |
 | `405` | `POST /events`. Plain-text body `method not allowed`. |
-| `503` | The server is in [degraded mode](./cli.md#degraded-mode). JSON `{"error": …}` body. |
+| `503` | The server is in [degraded mode](./cli.md#degraded-mode), or its filesystem watcher failed to start (for example, the inotify limit is exhausted). JSON `{"error": …}` body; for a watcher failure the message starts `filesystem watcher failed to start:` and gives the reason. `POST /query` keeps working. |

{dirsql-0.4.83 → dirsql-0.4.85}/docs/reference/sdk.md

@@ -301,6 +301,10 @@ under the root. The watcher starts on first iteration (Python/TypeScript)
 or at the `watch()` call (Rust). The stream never terminates on its own;
 stop consuming it to stop.
 
+Python: each `watch()` call returns an independent stream, and every stream
+on one instance receives every event observed after it was created, so
+several consumers (one per client, say) can share one instance.
+
 Rust: `watch()` may be called once per instance and is mutually exclusive
 with the polling API below — mixing them returns an error, since both drain
 the same underlying filesystem watcher.

{dirsql-0.4.83 → dirsql-0.4.85}/packages/python/Cargo.toml

@@ -4,7 +4,7 @@ name = "dirsql-py-ext"
 # pypi/maturin handler can rewrite it via `write-version` before
 # `maturin build`. `pyproject.toml` declares `dynamic = ["version"]`
 # and maturin reads this field. Mirrors `packages/rust/Cargo.toml`.
-version = "0.4.83"
+version = "0.4.85"
 # abi3 note: the `abi3-py310` pyo3 feature (below) builds ONE stable-ABI
 # `cp310-abi3` wheel per platform that loads on every CPython >= 3.10
 # (matching `pyproject.toml`'s `requires-python = ">=3.10"`), instead of

dirsql-0.4.85/packages/python/changelog.d/2026-10-06-one-glob-compiler.md

@@ -0,0 +1,3 @@
+**Changed** A declared `[[table]] glob` is compiled by the same glob compiler
+as a path-table, so brace ranges such as `f{1..3}.md` and the other bash brace
+rules now read the same on both surfaces.

dirsql-0.4.85/packages/python/changelog.d/2026-10-06-watch-broadcast.md

@@ -0,0 +1,3 @@
+**Fixed**
+
+- **Every `DirSQL.watch()` stream on one instance now receives every event.** Two or more streams (for example one per connected client) previously split the events between them; now each stream gets every event observed after it was created. (#1397)

dirsql-0.4.85/packages/python/changelog.d/2026-10-06-zero-match-config-table-warning.md

@@ -0,0 +1,3 @@
+**Added**
+
+- **A config `[[table]]` whose glob matches no files now prints a warning to stderr.** `dirsql: table 'sessions': glob 'projects/*/*.jsonl' matched no files under /home/u/.claude` names the table, the glob and the directory it was matched under, so a glob that silently indexes nothing is visible. The exit code is unchanged, and path-tables and programmatic tables do not warn. (#1232)

{dirsql-0.4.83 → dirsql-0.4.85/packages/python}/docs/reference/config.md

@@ -274,6 +274,10 @@ So `glob = "projects/*/*.jsonl"` in `~/.claude/.dirsql.toml` indexes
 writes `glob = "~/.claude/projects/*/*.jsonl"`. A table's `path` and `dir`
 columns, `{root}`, and `ignore` are all relative to its anchor.
 
+A table whose glob matches no files prints
+`dirsql: table 'sessions': glob 'projects/*/*.jsonl' matched no files under <anchor>`
+to stderr; the exit code is unchanged. Path-tables and programmatic tables do not warn.
+
 ### Batch `ddl`
 
 `ddl` is handed to SQLite whole, so a table declaration is not limited to one

{dirsql-0.4.83 → dirsql-0.4.85}/packages/python/docs/reference/http-api.md

@@ -112,4 +112,4 @@ Row values serialize as in [`POST /query`](#value-serialization).
 |---|---|
 | `200` | Stream opened (`text/event-stream`). |
 | `405` | `POST /events`. Plain-text body `method not allowed`. |
-| `503` | The server is in [degraded mode](./cli.md#degraded-mode). JSON `{"error": …}` body. |
+| `503` | The server is in [degraded mode](./cli.md#degraded-mode), or its filesystem watcher failed to start (for example, the inotify limit is exhausted). JSON `{"error": …}` body; for a watcher failure the message starts `filesystem watcher failed to start:` and gives the reason. `POST /query` keeps working. |

{dirsql-0.4.83/packages/rust → dirsql-0.4.85/packages/python}/docs/reference/sdk.md

@@ -301,6 +301,10 @@ under the root. The watcher starts on first iteration (Python/TypeScript)
 or at the `watch()` call (Rust). The stream never terminates on its own;
 stop consuming it to stop.
 
+Python: each `watch()` call returns an independent stream, and every stream
+on one instance receives every event observed after it was created, so
+several consumers (one per client, say) can share one instance.
+
 Rust: `watch()` may be called once per instance and is mutually exclusive
 with the polling API below — mixing them returns an error, since both drain
 the same underlying filesystem watcher.

dirsql-0.4.85/packages/python/e2e-attestations/bot-1397-watch-broadcast.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/on_file_query_test.py tests/e2e/fanout_test.py tests/e2e/query_contract_test.py tests/integration/binding/async_dirsql_test.py -x -q",
+  "ran_at": 1791309204,
+  "exit_code": 0,
+  "commit": "9a473a8812b974362a7c408132a9724aac50605a",
+  "branch": "bot/1397-watch-broadcast"
+}

dirsql-0.4.85/packages/python/e2e-attestations/bot-1398-inotify-error.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/cli_version_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1791309015,
+  "exit_code": 0,
+  "commit": "d60aff48881ae3201bccd0e6e77f52e6cd62c646",
+  "branch": "bot/1398-inotify-error"
+}

dirsql-0.4.85/packages/python/e2e-attestations/bot-1407-child-place-depth.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/fanout_test.py -x -q",
+  "ran_at": 1791310157,
+  "exit_code": 0,
+  "commit": "7104e6400efd6f912a92a53dd0d8f6d4c6c3a947",
+  "branch": "bot/1407-child-place-depth"
+}

dirsql-0.4.85/packages/python/e2e-attestations/claude-1232-zero-match.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/fanout_test.py tests/e2e/capture_collision_test.py tests/e2e/declared_table_name_test.py tests/e2e/extension_package_test.py tests/e2e/plugin_discovery_test.py tests/e2e/use_case_notebook_test.py tests/e2e/on_file_query_test.py tests/e2e/use_case_transcripts_test.py tests/e2e/plugin_extension_discovery_test.py tests/e2e/use_case_join_test.py tests/e2e/use_case_dossier_test.py tests/e2e/sigint_interrupt_test.py tests/e2e/query_contract_test.py -x -q",
+  "ran_at": 1791306078,
+  "exit_code": 0,
+  "commit": "8b587de39902adf33e4ebaa957a8fd0005875029",
+  "branch": "claude/1232-zero-match"
+}

dirsql-0.4.85/packages/python/e2e-attestations/claude-1258-one-pattern.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/capture_collision_test.py tests/e2e/declared_table_name_test.py tests/e2e/extension_package_test.py tests/e2e/query_contract_test.py tests/e2e/plugin_discovery_test.py tests/e2e/sigint_interrupt_test.py tests/e2e/fanout_test.py tests/e2e/use_case_transcripts_test.py tests/e2e/plugin_extension_discovery_test.py -x -q",
+  "ran_at": 1791301900,
+  "exit_code": 0,
+  "commit": "14d2a11edd69bb0715bbffdb085b1d6582728dd8",
+  "branch": "claude/1258-one-pattern"
+}

dirsql-0.4.85/packages/python/e2e-attestations/claude-1330-vtab-prefetch-flag.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/query_contract_test.py tests/e2e/declared_table_name_test.py tests/e2e/fanout_test.py -x -q",
+  "ran_at": 1791310416,
+  "exit_code": 0,
+  "commit": "bcedde49401cf6f9cc01deb2d95af1d1e907f0f7",
+  "branch": "claude/1330-vtab-prefetch-flag"
+}

dirsql-0.4.85/packages/python/migrations.d/2026-10-06-one-glob-compiler.md

@@ -0,0 +1,28 @@
+### Config table globs share the path-table glob compiler
+
+#### Summary
+
+A declared `[[table]] glob` is now compiled by the same compiler as a
+path-table. A brace range such as `f{1..3}.md` expands as in bash instead of
+matching nothing. Nothing else changes.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- `glob = "f{1..3}.md"` matches `f1.md`, `f2.md` and `f3.md`.
+
+#### Verification
+
+```bash
+cd "$(mktemp -d)"
+touch f1.md f2.md f3.md f4.md
+dirsql query "SELECT path FROM './f{1..3}.md' ORDER BY path"
+# expected: [{"path":"f1.md"},{"path":"f2.md"},{"path":"f3.md"}]
+```

dirsql-0.4.85/packages/python/migrations.d/2026-10-06-watch-broadcast.md

@@ -0,0 +1,46 @@
+### Every Python `watch()` stream receives every event (#1397)
+
+#### Summary
+
+Several `DirSQL.watch()` streams on one Python instance each receive every event, instead of splitting them. A single stream behaves as before. Nothing breaks.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- With more than one `watch()` stream on one instance, each stream now yields every event observed after it was created. Code that hand-rolled fan-out over one stream keeps working.
+
+#### Verification
+
+```python
+import asyncio, pathlib, tempfile
+from dirsql import DirSQL, Table
+
+async def main():
+    root = pathlib.Path(tempfile.mkdtemp())
+    table = Table(
+        name="files",
+        ddl="CREATE TABLE files (n INTEGER)",
+        glob="*.json",
+        on_file=lambda path: [{"n": 1}],
+    )
+    db = DirSQL(str(root), tables=[table])
+    await db.ready()
+
+    async def first(stream):
+        async for event in stream:
+            return event.action
+
+    tasks = [asyncio.create_task(first(db.watch())) for _ in range(2)]
+    await asyncio.sleep(0.3)
+    (root / "a.json").write_text("{}")
+    print(await asyncio.wait_for(asyncio.gather(*tasks), 5))  # ['insert', 'insert']
+
+asyncio.run(main())
+```

dirsql-0.4.85/packages/python/migrations.d/2026-10-06-zero-match-config-table-warning.md

@@ -0,0 +1,25 @@
+### Empty config tables warn on stderr (#1232)
+
+#### Summary
+
+A config `[[table]]` whose glob matches no files writes one line to stderr at startup. Nothing else changes: the query still runs and the exit code is the same.
+
+#### Required changes
+
+_None._ A script that treats any stderr output as failure should fix the glob or drop the table.
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- stderr gains `dirsql: table '<name>': glob '<glob>' matched no files under <anchor>` for each config table that matched nothing.
+
+#### Verification
+
+```bash
+mkdir -p /tmp/cfg /tmp/elsewhere
+printf '[[table]]\nname = "t"\nddl = "CREATE TABLE t (n TEXT)"\nglob = "nothing/*.jsonl"\non-file = "printf []"\n' > /tmp/cfg/.dirsql.toml
+cd /tmp/elsewhere && dirsql query "SELECT COUNT(*) AS n FROM t" -c /tmp/cfg/.dirsql.toml   # stderr: dirsql: table 't': glob 'nothing/*.jsonl' matched no files under /tmp/cfg
+```

{dirsql-0.4.83 → dirsql-0.4.85}/packages/rust/Cargo.toml

@@ -6,7 +6,7 @@ description = "Ephemeral SQL index over a local directory"
 # version stays for the binding crates (publish = false). The literal
 # intentionally lags the published version: putitoutthere rewrites it to
 # the planned release version at build time and never commits it back.
-version = "0.4.83"
+version = "0.4.85"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly

{dirsql-0.4.83/packages/python → dirsql-0.4.85/packages/rust}/docs/reference/config.md

@@ -274,6 +274,10 @@ So `glob = "projects/*/*.jsonl"` in `~/.claude/.dirsql.toml` indexes
 writes `glob = "~/.claude/projects/*/*.jsonl"`. A table's `path` and `dir`
 columns, `{root}`, and `ignore` are all relative to its anchor.
 
+A table whose glob matches no files prints
+`dirsql: table 'sessions': glob 'projects/*/*.jsonl' matched no files under <anchor>`
+to stderr; the exit code is unchanged. Path-tables and programmatic tables do not warn.
+
 ### Batch `ddl`
 
 `ddl` is handed to SQLite whole, so a table declaration is not limited to one

{dirsql-0.4.83 → dirsql-0.4.85/packages/rust}/docs/reference/http-api.md

@@ -112,4 +112,4 @@ Row values serialize as in [`POST /query`](#value-serialization).
 |---|---|
 | `200` | Stream opened (`text/event-stream`). |
 | `405` | `POST /events`. Plain-text body `method not allowed`. |
-| `503` | The server is in [degraded mode](./cli.md#degraded-mode). JSON `{"error": …}` body. |
+| `503` | The server is in [degraded mode](./cli.md#degraded-mode), or its filesystem watcher failed to start (for example, the inotify limit is exhausted). JSON `{"error": …}` body; for a watcher failure the message starts `filesystem watcher failed to start:` and gives the reason. `POST /query` keeps working. |

{dirsql-0.4.83/packages/python → dirsql-0.4.85/packages/rust}/docs/reference/sdk.md

@@ -301,6 +301,10 @@ under the root. The watcher starts on first iteration (Python/TypeScript)
 or at the `watch()` call (Rust). The stream never terminates on its own;
 stop consuming it to stop.
 
+Python: each `watch()` call returns an independent stream, and every stream
+on one instance receives every event observed after it was created, so
+several consumers (one per client, say) can share one instance.
+
 Rust: `watch()` may be called once per instance and is mutually exclusive
 with the polling API below — mixing them returns an error, since both drain
 the same underlying filesystem watcher.

{dirsql-0.4.83 → dirsql-0.4.85}/packages/rust/src/cli/router.rs

@@ -26,6 +26,7 @@ use super::execute::{QueryFailure, execute_query, require_ready};
 pub(super) struct AppContext {
     pub state: AppState,
     pub events: broadcast::Sender<String>,
+    pub watch_failure: Option<String>,
     pub cancel: watch::Receiver<bool>,
     pub query_timeout: Duration,
 }
@@ -72,6 +73,9 @@ async fn handle_events(State(ctx): State<SharedCtx>) -> Response {
     if let Err(failure) = require_ready(&ctx.state) {
         return failure_response(&failure);
     }
+    if let Some(reason) = &ctx.watch_failure {
+        return failure_response(&QueryFailure::Unavailable(reason.clone()));
+    }
 
     // Subscribe BEFORE anything that might block so we don't drop events
     // that fire between subscribing and the first poll.
@@ -163,6 +167,21 @@ mod tests {
         );
     }
 
+    #[tokio::test]
+    async fn events_return_503_while_the_server_is_unavailable() {
+        let (events, _) = broadcast::channel::<String>(1);
+        let (_cancel_tx, cancel) = watch::channel(false);
+        let ctx = Arc::new(AppContext {
+            state: AppState::Unavailable("config failed to load".into()),
+            events,
+            watch_failure: None,
+            cancel,
+            query_timeout: Duration::from_secs(1),
+        });
+        let resp = handle_events(State(ctx)).await;
+        assert_eq!(resp.status(), StatusCode::SERVICE_UNAVAILABLE);
+    }
+
     #[test]
     fn error_response_sets_json_content_type() {
         let resp = error_response(StatusCode::BAD_REQUEST, "boom");

{dirsql-0.4.83 → dirsql-0.4.85}/packages/rust/src/cli/server.rs

@@ -38,14 +38,16 @@ pub async fn serve_with_state(
     // the underlying notify watcher (which `DirSQL::watch` only permits
     // once per instance).
     let (event_tx, _) = broadcast::channel::<String>(256);
-    if let AppState::Ready(ref db) = state {
-        start_watch_task(db.clone(), event_tx.clone());
-    }
+    let watch_failure = match state {
+        AppState::Ready(ref db) => start_watch_task(db.clone(), event_tx.clone()),
+        AppState::Unavailable(_) => None,
+    };
 
     let (cancel_tx, cancel_rx) = watch::channel(false);
     let shared = Arc::new(AppContext {
         state,
         events: event_tx,
+        watch_failure,
         cancel: cancel_rx,
         query_timeout: config.query_timeout,
     });
@@ -69,18 +71,20 @@ pub async fn serve_with_state(
     })
 }
 
-fn start_watch_task(db: DirSQL, tx: broadcast::Sender<String>) {
+/// Returns the reason `/events` must refuse requests when the watcher
+/// could not attach.
+fn start_watch_task(db: DirSQL, tx: broadcast::Sender<String>) -> Option<String> {
     // `db.watch()` spawns its own OS thread and returns an async stream.
     // We pump the stream into the broadcast channel. If no subscribers
     // exist, send() errors but we keep pumping (future subscribers
     // will get subsequent events).
-    let Ok(mut stream) = db.watch().map_err(|err| {
-        eprintln!(
-            "dirsql: failed to attach filesystem watcher ({err}); \
-             /events will return an empty stream"
-        );
-    }) else {
-        return;
+    let mut stream = match db.watch() {
+        Ok(stream) => stream,
+        Err(err) => {
+            let reason = format!("filesystem watcher failed to start: {err}");
+            eprintln!("dirsql: {reason}; /events will return 503");
+            return Some(reason);
+        }
     };
     tokio::spawn(async move {
         while let Some(event) = stream.next().await {
@@ -88,6 +92,7 @@ fn start_watch_task(db: DirSQL, tx: broadcast::Sender<String>) {
             let _ = tx.send(payload);
         }
     });
+    None
 }
 
 #[cfg(test)]
@@ -122,6 +127,29 @@ mod tests {
         handle.shutdown().await.expect("graceful shutdown");
     }
 
+    #[tokio::test]
+    async fn start_watch_task_reports_no_failure_once_the_watcher_attaches() {
+        let dir = tempfile::tempdir().unwrap();
+        let db = DirSQL::new(dir.path(), Vec::new()).unwrap();
+        let (tx, _) = broadcast::channel::<String>(1);
+        assert_eq!(start_watch_task(db, tx), None);
+    }
+
+    // `poll_events` locks out `watch`, the one deterministic way to make the
+    // watcher refuse to attach without exhausting inotify.
+    #[tokio::test]
+    async fn start_watch_task_returns_the_reason_when_the_watcher_cannot_attach() {
+        let dir = tempfile::tempdir().unwrap();
+        let db = DirSQL::new(dir.path(), Vec::new()).unwrap();
+        db.poll_events(std::time::Duration::ZERO).unwrap();
+        let (tx, _) = broadcast::channel::<String>(1);
+        let reason = start_watch_task(db, tx).expect("watch() must fail");
+        assert!(
+            reason.starts_with("filesystem watcher failed to start: "),
+            "got: {reason}"
+        );
+    }
+
     // Binding to a non-local TEST-NET address (RFC 5737) fails with
     // "cannot assign requested address", surfacing `ServerError::Bind` rather
     // than panicking — deterministic and DNS-free.