dirsql 0.3.90__tar.gz → 0.3.92__tar.gz

{dirsql-0.3.90 → dirsql-0.3.92}/Cargo.lock

@@ -500,7 +500,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.3.90"
+version = "0.3.92"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.3.90 → dirsql-0.3.92}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.3.90
+Version: 0.3.92
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index
 Author: Kevin Scott

{dirsql-0.3.90/packages/rust → dirsql-0.3.92}/docs/reference/sdk.md

@@ -81,8 +81,8 @@ DirSQL::builder()
     .tables(tables)                 // optional; append one with .table(t)
     .ignore(patterns)               // optional
     .config(config_toml_path)       // optional
-    .persist(true)                  // optional; default false
-    .persist_path(path)             // optional
+    .persist(cache_path)            // optional; Some(path), or None for the
+                                    //   default <root>/.dirsql/cache.db
     .extensions(extensions)         // optional; append one with .extension(e)
     .poll_interval(duration)        // optional; watch-loop cadence, default 200ms
     .build()                        // -> Result<DirSQL>  (synchronous scan)
@@ -114,7 +114,10 @@ directory" error.
   changed are re-parsed. (The CLI exposes the same switch as the
   [`--persist [PATH]`](./cli.md#server-mode) flag; it is not a config key.)
 - `persist_path` / `persistPath` — Override the cache location. Ignored when
-  persistence is off. Constructor values are used as given.
+  persistence is off. Constructor values are used as given. In Rust these two
+  parameters collapse into a single builder method: `.persist(None)` enables
+  persistence at the default location, `.persist(Some(path))` enables it at
+  `path`.
 - `extensions` — SQLite extensions to load at startup, before any table
   DDL (enable → load → disable, so SQL `load_extension()` is never
   exposed). Each entry pairs a shared-library `path` with an optional

{dirsql-0.3.90 → dirsql-0.3.92}/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.3.90"
+version = "0.3.92"
 # abi3 note: the `abi3-py311` pyo3 feature (below) builds ONE stable-ABI
 # `cp311-abi3` wheel per platform that loads on every CPython >= 3.11
 # (matching `pyproject.toml`'s `requires-python = ">=3.11"`), instead of

{dirsql-0.3.90 → dirsql-0.3.92/packages/python}/docs/reference/sdk.md

@@ -81,8 +81,8 @@ DirSQL::builder()
     .tables(tables)                 // optional; append one with .table(t)
     .ignore(patterns)               // optional
     .config(config_toml_path)       // optional
-    .persist(true)                  // optional; default false
-    .persist_path(path)             // optional
+    .persist(cache_path)            // optional; Some(path), or None for the
+                                    //   default <root>/.dirsql/cache.db
     .extensions(extensions)         // optional; append one with .extension(e)
     .poll_interval(duration)        // optional; watch-loop cadence, default 200ms
     .build()                        // -> Result<DirSQL>  (synchronous scan)
@@ -114,7 +114,10 @@ directory" error.
   changed are re-parsed. (The CLI exposes the same switch as the
   [`--persist [PATH]`](./cli.md#server-mode) flag; it is not a config key.)
 - `persist_path` / `persistPath` — Override the cache location. Ignored when
-  persistence is off. Constructor values are used as given.
+  persistence is off. Constructor values are used as given. In Rust these two
+  parameters collapse into a single builder method: `.persist(None)` enables
+  persistence at the default location, `.persist(Some(path))` enables it at
+  `path`.
 - `extensions` — SQLite extensions to load at startup, before any table
   DDL (enable → load → disable, so SQL `load_extension()` is never
   exposed). Each entry pairs a shared-library `path` with an optional

dirsql-0.3.92/packages/python/e2e-attestations/worktree-agent-a1a637f59ef70f352.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1783641235,
+  "exit_code": 0,
+  "commit": "e8cda44abdfccb421ad06ec83c77bd644fb2bb83",
+  "branch": "worktree-agent-a1a637f59ef70f352"
+}

{dirsql-0.3.90 → dirsql-0.3.92}/packages/python/src/lib.rs

@@ -154,10 +154,7 @@ mod python {
                         builder = builder.config(c);
                     }
                     if persist {
-                        builder = builder.persist(true);
-                    }
-                    if let Some(p) = persist_path {
-                        builder = builder.persist_path(p);
+                        builder = builder.persist(persist_path);
                     }
                     if !rust_extensions.is_empty() {
                         builder = builder.extensions(rust_extensions);

{dirsql-0.3.90/packages/python → dirsql-0.3.92/packages/rust}/docs/reference/sdk.md

@@ -81,8 +81,8 @@ DirSQL::builder()
     .tables(tables)                 // optional; append one with .table(t)
     .ignore(patterns)               // optional
     .config(config_toml_path)       // optional
-    .persist(true)                  // optional; default false
-    .persist_path(path)             // optional
+    .persist(cache_path)            // optional; Some(path), or None for the
+                                    //   default <root>/.dirsql/cache.db
     .extensions(extensions)         // optional; append one with .extension(e)
     .poll_interval(duration)        // optional; watch-loop cadence, default 200ms
     .build()                        // -> Result<DirSQL>  (synchronous scan)
@@ -114,7 +114,10 @@ directory" error.
   changed are re-parsed. (The CLI exposes the same switch as the
   [`--persist [PATH]`](./cli.md#server-mode) flag; it is not a config key.)
 - `persist_path` / `persistPath` — Override the cache location. Ignored when
-  persistence is off. Constructor values are used as given.
+  persistence is off. Constructor values are used as given. In Rust these two
+  parameters collapse into a single builder method: `.persist(None)` enables
+  persistence at the default location, `.persist(Some(path))` enables it at
+  `path`.
 - `extensions` — SQLite extensions to load at startup, before any table
   DDL (enable → load → disable, so SQL `load_extension()` is never
   exposed). Each entry pairs a shared-library `path` with an optional

{dirsql-0.3.90 → dirsql-0.3.92}/packages/rust/src/bin/dirsql.rs

@@ -76,10 +76,7 @@ impl Cli {
     /// → persist at `<path>`.
     fn apply_persist(&self, mut builder: dirsql::DirSQLBuilder) -> dirsql::DirSQLBuilder {
         if let Some(path) = &self.persist {
-            builder = builder.persist(true);
-            if let Some(path) = path {
-                builder = builder.persist_path(path);
-            }
+            builder = builder.persist(path.as_ref());
         }
         builder
     }

{dirsql-0.3.90 → dirsql-0.3.92}/packages/rust/src/lib.rs

@@ -932,20 +932,15 @@ impl DirSQLBuilder {
         self
     }
 
-    /// Enable persistent on-disk storage. When `true`, the SQLite database is
-    /// written to `<root>/.dirsql/cache.db` (override via
-    /// [`persist_path`](Self::persist_path)) so subsequent startups only
-    /// re-parse files that have actually changed. See
-    /// `docs/howto/persist.md` for the reconcile contract.
-    pub fn persist(mut self, persist: bool) -> Self {
-        self.persist = persist;
-        self
-    }
-
-    /// Override the location of the persistent cache file. Ignored when
-    /// [`persist`](Self::persist) is `false`.
-    pub fn persist_path(mut self, path: impl AsRef<Path>) -> Self {
-        self.persist_path = Some(path.as_ref().to_path_buf());
+    /// Enable persistent on-disk storage. `None` writes the SQLite database to
+    /// the default `<root>/.dirsql/cache.db`; `Some(path)` writes it to `path`.
+    /// Either way, subsequent startups only re-parse files that have actually
+    /// changed. See `docs/howto/persist.md` for the reconcile contract.
+    pub fn persist(mut self, path: Option<impl AsRef<Path>>) -> Self {
+        self.persist = true;
+        if let Some(path) = path {
+            self.persist_path = Some(path.as_ref().to_path_buf());
+        }
         self
     }
 
@@ -972,8 +967,13 @@ impl DirSQLBuilder {
             poll_interval,
         } = self;
 
-        let mut config_root: Option<PathBuf> = None;
-
+        // The config layer is an ordered list of entries, each carrying its
+        // loaded `config`, its `config_dir` (where `on-file` hooks run and the
+        // base for extension/persist path resolution), its resolved index
+        // `root` (the base for `{path}`), and its `hook_timeout`. Every caller
+        // supplies at most one config, so the list holds 0 or 1 entries and the
+        // in-order merge below is byte-for-byte identical to a single pass.
+        let mut config_entries: Vec<ResolvedConfigEntry> = Vec::new();
         if let Some(ref cfg_path) = config_path {
             let cfg = config::load_config(cfg_path).map_err(DirSqlError::config)?;
 
@@ -990,12 +990,30 @@ impl DirSQLBuilder {
             } else {
                 cfg_parent.clone()
             };
+            let hook_timeout = cfg.hook_timeout.unwrap_or(command::DEFAULT_COMMAND_TIMEOUT);
+            config_entries.push(ResolvedConfigEntry {
+                config: cfg,
+                config_dir: cfg_parent,
+                root: resolved_root,
+                hook_timeout,
+            });
+        }
+
+        let mut config_root: Option<PathBuf> = None;
+        for entry in config_entries {
+            let ResolvedConfigEntry {
+                config: cfg,
+                config_dir: cfg_parent,
+                root: resolved_root,
+                hook_timeout,
+            } = entry;
             config_root = Some(resolved_root.clone());
 
             // `on-file` commands run in the config file's directory; `{path}`
             // is the matched file's absolute path and `{root}` the resolved
             // index root.
-            let cfg_tables = build_tables_from_config(&cfg, &cfg_parent, &resolved_root)?;
+            let cfg_tables =
+                build_tables_from_config(&cfg, &cfg_parent, &resolved_root, hook_timeout)?;
             tables.extend(cfg_tables);
             ignore.extend(cfg.ignore);
 
@@ -1075,6 +1093,18 @@ impl DirSQLBuilder {
 /// Default poll interval for the channel-based watch loop.
 const DEFAULT_POLL_INTERVAL: Duration = Duration::from_millis(200);
 
+/// One resolved config file in the ordered list [`DirSQLBuilder::resolve`]
+/// merges over. Carries the loaded `config`, its `config_dir` (the config
+/// file's parent -- where `on-file` hooks run and the base for extension /
+/// persist path resolution), the resolved index `root` (the base for the
+/// `{path}` placeholder), and the `hook_timeout` bounding each `on-file` run.
+struct ResolvedConfigEntry {
+    config: config::Config,
+    config_dir: PathBuf,
+    root: PathBuf,
+    hook_timeout: Duration,
+}
+
 /// Fully-resolved builder inputs: the result of merging programmatic
 /// settings with values loaded from a `.dirsql.toml` config file.
 #[doc(hidden)]
@@ -1366,16 +1396,17 @@ fn relative_path(root: &Path, path: &Path) -> String {
 /// array of row objects on stdout, which becomes the file's rows (filesystem
 /// facts are still merged on top, user values winning). `config_dir` is the
 /// command's working directory (the config file's parent) and `root` is the
-/// resolved index root exposed as the `{root}` placeholder. Each run is
-/// bounded by the global `[dirsql].hook-timeout` key when present, falling
-/// back to [`command::DEFAULT_COMMAND_TIMEOUT`].
+/// resolved index root exposed as the `{root}` placeholder. `timeout` bounds
+/// each `on-file` run; the caller resolves it from the global
+/// `[dirsql].hook-timeout` key, falling back to
+/// [`command::DEFAULT_COMMAND_TIMEOUT`].
 fn build_tables_from_config(
     cfg: &config::Config,
     config_dir: &Path,
     root: &Path,
+    timeout: Duration,
 ) -> Result<Vec<Table>> {
     let mut tables = Vec::with_capacity(cfg.tables.len());
-    let timeout = cfg.hook_timeout.unwrap_or(command::DEFAULT_COMMAND_TIMEOUT);
 
     for table_cfg in &cfg.tables {
         let mut table = match &table_cfg.on_file {
@@ -2651,8 +2682,7 @@ mod internal_tests {
             .ignore(["skip/**"])
             .extensions(Vec::<Extension>::new())
             .suppress_config_extensions(true)
-            .persist(true)
-            .persist_path(&cache)
+            .persist(Some(&cache))
             .poll_interval(Duration::from_millis(50))
             .build()
             .unwrap();
@@ -2661,6 +2691,38 @@ mod internal_tests {
         assert_eq!(db.inner.poll_interval, Duration::from_millis(50));
     }
 
+    #[test]
+    fn persist_none_enables_default_path() {
+        let resolved = DirSQL::builder()
+            .root("/tmp/x")
+            .persist(None::<&Path>)
+            .resolve()
+            .unwrap();
+        assert!(resolved.persist);
+        assert!(resolved.persist_path.is_none());
+    }
+
+    #[test]
+    fn persist_some_enables_explicit_path() {
+        let resolved = DirSQL::builder()
+            .root("/tmp/x")
+            .persist(Some("/tmp/x/custom.db"))
+            .resolve()
+            .unwrap();
+        assert!(resolved.persist);
+        assert_eq!(
+            resolved.persist_path,
+            Some(PathBuf::from("/tmp/x/custom.db"))
+        );
+    }
+
+    #[test]
+    fn persist_unset_leaves_persistence_off() {
+        let resolved = DirSQL::builder().root("/tmp/x").resolve().unwrap();
+        assert!(!resolved.persist);
+        assert!(resolved.persist_path.is_none());
+    }
+
     /// A second persist build over the same root+cache finds a compatible
     /// meta block and reuses the cache instead of a cold rebuild.
     #[test]
@@ -2674,8 +2736,7 @@ mod internal_tests {
                 "*.txt",
                 |_| vec![],
             )])
-            .persist(true)
-            .persist_path(&cache)
+            .persist(Some(&cache))
             .build()
             .unwrap();
         drop(first);
@@ -2686,8 +2747,7 @@ mod internal_tests {
                 "*.txt",
                 |_| vec![],
             )])
-            .persist(true)
-            .persist_path(&cache)
+            .persist(Some(&cache))
             .build()
             .unwrap();
         assert!(second.query("SELECT * FROM t").is_ok());
@@ -2847,12 +2907,46 @@ mod internal_tests {
         ))
         .unwrap();
         let dir = TempDir::new().unwrap();
-        let tables = build_tables_from_config(&cfg, dir.path(), dir.path()).unwrap();
+        let tables = build_tables_from_config(
+            &cfg,
+            dir.path(),
+            dir.path(),
+            command::DEFAULT_COMMAND_TIMEOUT,
+        )
+        .unwrap();
         assert_eq!(tables.len(), 2);
         assert_eq!((tables[0].extract)("/whatever").unwrap().len(), 1);
         assert!(tables[1].strict, "on-file table preserves strict flag");
     }
 
+    #[test]
+    fn build_tables_from_config_uses_the_caller_supplied_timeout() {
+        // The timeout is now threaded in as an explicit argument rather than
+        // re-derived from `cfg.hook_timeout` inside the function; a table built
+        // from a config declaring its own `hook-timeout` must honor the value
+        // the caller passes, independent of the config key.
+        let cfg = config::load_config_str(concat!(
+            "[dirsql]\n",
+            "hook-timeout = 999\n\n",
+            "[[table]]\n",
+            "ddl = \"CREATE TABLE b (y TEXT)\"\n",
+            "glob = \"*.b\"\n",
+            "on-file = \"printf '[{\\\"y\\\":1}]'\"\n",
+        ))
+        .unwrap();
+        let dir = TempDir::new().unwrap();
+        let abs = dir.path().join("f.b");
+        let tables =
+            build_tables_from_config(&cfg, dir.path(), dir.path(), Duration::from_secs(5)).unwrap();
+        assert_eq!(tables.len(), 1);
+        // The passed timeout is generous, so the on-file command runs and its
+        // row is produced -- proving the argument path is live.
+        assert_eq!(
+            (tables[0].extract)(&abs.to_string_lossy()).unwrap().len(),
+            1
+        );
+    }
+
     #[test]
     fn run_on_file_parses_command_json_output() {
         let dir = TempDir::new().unwrap();

dirsql-0.3.90/packages/python/e2e-attestation.json

@@ -1,6 +0,0 @@
-{
-  "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1783637710,
-  "exit_code": 0,
-  "commit": "c7c626ca03beb1b23e26ab96febf3c9df5d4a67f"
-}