dirsql 0.4.83__tar.gz → 0.4.84__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.83
+Version: 0.4.84
 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.84}/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.84}/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.84}/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.84}/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.84"
 # 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.84/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.84/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.84/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/packages/rust → dirsql-0.4.84/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.84/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.84/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.84/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.84/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.84}/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.84"
 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.84/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/packages/python → dirsql-0.4.84/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.84}/packages/rust/src/lib.rs

@@ -285,6 +285,7 @@ pub struct Table {
     hook: Hook,
     anchor: Option<PathBuf>,
     ignore: Vec<String>,
+    warn_when_empty: bool,
 }
 
 impl Table {
@@ -298,6 +299,11 @@ impl Table {
         &self.ignore
     }
 
+    pub(crate) fn warning_when_empty(mut self) -> Self {
+        self.warn_when_empty = true;
+        self
+    }
+
     pub(crate) fn scoped_ignore(mut self, ignore: Vec<String>) -> Self {
         self.ignore = ignore;
         self
@@ -354,6 +360,7 @@ impl Table {
             strict: false,
             anchor: None,
             ignore: Vec::new(),
+            warn_when_empty: false,
         }
     }
 
@@ -400,6 +407,7 @@ impl Table {
             strict: false,
             anchor: None,
             ignore: Vec::new(),
+            warn_when_empty: false,
         }
     }
 }
@@ -1128,6 +1136,9 @@ impl DirSQL {
             let mut progress = Progress::scanning();
             let (scanned, seen) = scan_groups(&groups, scan, &mut progress);
             progress.finish(seen);
+            for warning in empty_table_warnings(&tables, &anchors, &scanned) {
+                eprintln!("{warning}");
+            }
             scanned
         };
 
@@ -2019,6 +2030,28 @@ fn compile_groups(
     Ok((groups, anchors, names))
 }
 
+/// One stderr line per config table that matched no file in the scan, naming
+/// the table, its glob and the directory the glob was matched under.
+fn empty_table_warnings(
+    tables: &[Table],
+    anchors: &TableAnchors,
+    scanned: &[(PathBuf, String)],
+) -> Vec<String> {
+    tables
+        .iter()
+        .filter(|table| table.warn_when_empty)
+        .filter(|table| !scanned.iter().any(|(_, name)| *name == table.name))
+        .map(|table| {
+            format!(
+                "dirsql: table '{}': glob '{}' matched no files under {}",
+                table.name,
+                table.glob,
+                anchors.of(&table.name).display()
+            )
+        })
+        .collect()
+}
+
 /// Open (or create) the persistent SQLite cache and read its meta. If the
 /// meta is missing or incompatible with the current build, the resulting
 /// [`PersistContext`] carries an empty file index and asks for a sweep, so
@@ -2423,7 +2456,8 @@ fn build_tables_from_config(cfg: &config::Config, config_dir: &Path) -> Result<V
             },
         )
         .anchored(anchor)
-        .scoped_ignore(cfg.ignore.clone());
+        .scoped_ignore(cfg.ignore.clone())
+        .warning_when_empty();
 
         if table_cfg.strict == Some(true) {
             table.strict = true;
@@ -5451,6 +5485,31 @@ mod internal_tests {
         assert!(matches!(err, DirSqlError::DuplicateTable(ref name) if name == "a"));
     }
 
+    #[test]
+    fn an_empty_warning_table_is_named_with_its_glob_and_anchor() {
+        let tables = vec![anchored_table("a", "*.txt", "/one").warning_when_empty()];
+        let anchors = compile_groups(&tables, &[], Path::new("/idx")).unwrap().1;
+        assert_eq!(
+            empty_table_warnings(&tables, &anchors, &[]),
+            vec!["dirsql: table 'a': glob '*.txt' matched no files under /one".to_string()]
+        );
+    }
+
+    #[test]
+    fn a_table_with_a_matched_file_does_not_warn() {
+        let tables = vec![anchored_table("a", "*.txt", "/one").warning_when_empty()];
+        let anchors = compile_groups(&tables, &[], Path::new("/idx")).unwrap().1;
+        let scanned = vec![(PathBuf::from("/one/x.txt"), "a".to_string())];
+        assert!(empty_table_warnings(&tables, &anchors, &scanned).is_empty());
+    }
+
+    #[test]
+    fn a_programmatic_empty_table_does_not_warn() {
+        let tables = vec![anchored_table("a", "*.txt", "/one")];
+        let anchors = compile_groups(&tables, &[], Path::new("/idx")).unwrap().1;
+        assert!(empty_table_warnings(&tables, &anchors, &[]).is_empty());
+    }
+
     #[test]
     fn anchors_of_an_unknown_table_is_the_index_root() {
         let anchors = TableAnchors::at_root(Path::new("/idx"));