dirsql 0.4.39__tar.gz → 0.4.41__tar.gz

{dirsql-0.4.39 → dirsql-0.4.41}/Cargo.lock

@@ -540,7 +540,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.39"
+version = "0.4.41"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -583,7 +583,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.39"
+version = "0.4.41"
 dependencies = [
  "dirsql",
  "pyo3",

{dirsql-0.4.39 → dirsql-0.4.41}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.39
+Version: 0.4.41
 Requires-Dist: tomli>=2 ; python_full_version < '3.11'
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory

{dirsql-0.4.39 → dirsql-0.4.41}/dirsql/_dirsql.pyi

@@ -77,3 +77,5 @@ class DirSQL:
     def query(self, sql: str) -> list[Row]: ...
     def _start_watcher(self) -> None: ...
     def _poll_events(self, timeout_ms: int) -> list[RowEvent]: ...
+
+def config_paths_from_argv(argv: list[str]) -> list[str]: ...

{dirsql-0.4.39 → dirsql-0.4.41}/dirsql/cli/resolve_config_extensions.py

@@ -15,8 +15,8 @@ carries resolved paths.
 
 from __future__ import annotations
 
+from .._dirsql import config_paths_from_argv
 from ..resolve_configs_extension_specs import resolve_configs_extension_specs
-from .config_paths_from_argv import config_paths_from_argv
 
 # Config extensions the binary dispatches to `dirsql interpret`; never
 # pre-resolved here (that path resolves via the handshake).

{dirsql-0.4.39 → dirsql-0.4.41}/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.39"
+version = "0.4.41"
 # 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.41/packages/python/changelog.d/2026-09-09-launcher-config-path-scan.md

@@ -0,0 +1,3 @@
+**Changed**
+
+- **The launcher's config-path scan now runs in the shared core.** Before clap sees argv, the pip launcher still walks it for every `--config` / `-c` value (all five spellings) so a bare package-name `[[dirsql.extension]]` entry can be resolved through `importlib` — but the walk itself is now `dirsql::launcher::config_paths_from_argv`, reached through the private `dirsql._dirsql.config_paths_from_argv` binding; the Python copy is deleted. No user-observable change: same flags, same paths, same default of `./.dirsql.toml`. (#1078, #1072)

dirsql-0.4.41/packages/python/e2e-attestations/claude-1078-argv-config-paths-core.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1788979577,
+  "exit_code": 0,
+  "commit": "ae4f94c0b871cd766d45be67204c8a523a58c707",
+  "branch": "claude/1078-argv-config-paths-core"
+}

dirsql-0.4.41/packages/python/e2e-attestations/claude-1096-watch-moved-dir.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1788980718,
+  "exit_code": 0,
+  "commit": "f1d452531516e25204fbc4a2bdc3233d036a00f5",
+  "branch": "claude/1096-watch-moved-dir"
+}

{dirsql-0.4.39 → dirsql-0.4.41}/packages/python/src/lib.rs

@@ -462,6 +462,13 @@ mod python {
         py.detach(|| dirsql::cli::run_cli(full))
     }
 
+    /// The config paths a launcher must inspect for package-name extensions;
+    /// see [`dirsql::launcher::config_paths_from_argv`].
+    #[pyfunction]
+    fn config_paths_from_argv(argv: Vec<String>) -> Vec<String> {
+        dirsql::launcher::config_paths_from_argv(&argv)
+    }
+
     #[pymodule]
     #[pyo3(name = "_dirsql")]
     fn py_dirsql_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
@@ -471,6 +478,7 @@ mod python {
         m.add_class::<PyRowEvent>()?;
         m.add_class::<PyScanFailure>()?;
         m.add_function(wrap_pyfunction!(run_cli, m)?)?;
+        m.add_function(wrap_pyfunction!(config_paths_from_argv, m)?)?;
         Ok(())
     }
 
@@ -553,6 +561,14 @@ mod python {
             assert_eq!(OnFileError("bad".to_string()).to_string(), "bad");
         }
 
+        #[test]
+        fn config_paths_from_argv_forwards_to_the_core_scan() {
+            assert_eq!(
+                config_paths_from_argv(vec!["-c".into(), "a.toml".into()]),
+                ["a.toml"]
+            );
+        }
+
         #[test]
         fn int_overflow_message_names_the_value() {
             let m = int_overflow_message("9223372036854775808");

{dirsql-0.4.39 → dirsql-0.4.41}/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.39"
+version = "0.4.41"
 edition.workspace = true
 # Literal `license` (not `license.workspace = true`) because
 # putitoutthere's preflight check reads `[package].license` directly

dirsql-0.4.41/packages/rust/src/launcher.rs

@@ -0,0 +1,168 @@
+//! Argv scanning the language launchers share.
+//!
+//! The pip and npm launchers must know which config files an invocation names
+//! *before* the core parses argv: a config's `[[dirsql.extension]]` entry may
+//! name an extension by bare package name, and resolving that needs the
+//! interpreter the launcher has and this crate does not. Everything about
+//! locating those config paths is language-neutral, so it lives here and each
+//! launcher reaches it through its binding rather than reimplementing it.
+
+/// The config a launcher inspects when argv names none.
+const DEFAULT_CONFIG_PATH: &str = "./.dirsql.toml";
+
+/// Every config value in `argv`, in order (`--config X`, `--config=X`,
+/// `-c X`, `-c=X`, `-cX`), or [`DEFAULT_CONFIG_PATH`] when argv names none.
+///
+/// The scan is deliberately looser than clap: it runs before argv is parsed,
+/// only to find files to read extensions out of, so a bare trailing `-c`
+/// yields an empty string rather than an error. A malformed invocation is
+/// clap's to reject once the launcher hands argv over.
+pub fn config_paths_from_argv(argv: &[String]) -> Vec<String> {
+    let mut paths = Vec::new();
+    let mut args = argv.iter();
+    while let Some(arg) = args.next() {
+        if arg == "--config" || arg == "-c" {
+            paths.push(args.next().cloned().unwrap_or_default());
+        } else if let Some(value) = arg.strip_prefix("--config=") {
+            paths.push(value.to_string());
+        } else if let Some(value) = arg.strip_prefix("-c") {
+            paths.push(value.strip_prefix('=').unwrap_or(value).to_string());
+        }
+    }
+    if paths.is_empty() {
+        paths.push(DEFAULT_CONFIG_PATH.to_string());
+    }
+    paths
+}
+
+#[cfg(test)]
+mod tests {
+    use super::config_paths_from_argv;
+
+    fn scan(argv: &[&str]) -> Vec<String> {
+        config_paths_from_argv(&argv.iter().map(|a| (*a).to_string()).collect::<Vec<_>>())
+    }
+
+    #[test]
+    fn reads_the_long_config_form() {
+        assert_eq!(
+            scan(&["--config", "/cfg/.dirsql.toml"]),
+            ["/cfg/.dirsql.toml"]
+        );
+    }
+
+    #[test]
+    fn reads_the_long_config_equals_form() {
+        assert_eq!(scan(&["--config=/c/.dirsql.toml"]), ["/c/.dirsql.toml"]);
+    }
+
+    #[test]
+    fn reads_the_short_c_form() {
+        assert_eq!(scan(&["-c", "/frag/dirsql.toml"]), ["/frag/dirsql.toml"]);
+    }
+
+    #[test]
+    fn reads_the_short_c_equals_form() {
+        assert_eq!(scan(&["-c=/frag/dirsql.toml"]), ["/frag/dirsql.toml"]);
+    }
+
+    #[test]
+    fn reads_the_short_c_attached_form() {
+        assert_eq!(scan(&["-c/frag/dirsql.toml"]), ["/frag/dirsql.toml"]);
+    }
+
+    #[test]
+    fn collects_every_config_flag_in_argv_order() {
+        assert_eq!(
+            scan(&[
+                "-c",
+                "a.toml",
+                "--config",
+                "b.toml",
+                "--config=c.toml",
+                "-cd.toml"
+            ]),
+            ["a.toml", "b.toml", "c.toml", "d.toml"]
+        );
+    }
+
+    #[test]
+    fn reads_the_config_value_at_any_argv_position() {
+        assert_eq!(scan(&["-v", "--config", "/x/y", "tail"]), ["/x/y"]);
+    }
+
+    #[test]
+    fn collects_a_discovery_injected_fragment_rather_than_the_default() {
+        assert_eq!(
+            scan(&[
+                "query",
+                "SELECT 1",
+                "--include-default",
+                "-c",
+                "/frag/dirsql.toml"
+            ]),
+            ["/frag/dirsql.toml"]
+        );
+    }
+
+    #[test]
+    fn consumes_a_config_value_that_looks_like_a_flag() {
+        assert_eq!(scan(&["--config", "-cx.toml"]), ["-cx.toml"]);
+    }
+
+    #[test]
+    fn consumes_a_config_value_that_is_itself_a_config_flag() {
+        assert_eq!(scan(&["-c", "-c", "x"]), ["-c"]);
+    }
+
+    #[test]
+    fn does_not_mistake_other_short_flags_for_config() {
+        assert_eq!(scan(&["-v", "-x", "val"]), ["./.dirsql.toml"]);
+    }
+
+    #[test]
+    fn does_not_mistake_other_long_flags_for_config() {
+        assert_eq!(scan(&["--a", "val"]), ["./.dirsql.toml"]);
+    }
+
+    #[test]
+    fn does_not_mistake_a_config_prefixed_long_flag_for_config() {
+        assert_eq!(scan(&["--configuration", "val"]), ["./.dirsql.toml"]);
+    }
+
+    #[test]
+    fn defaults_when_no_config_flag_is_given() {
+        assert_eq!(scan(&["--port", "9000"]), ["./.dirsql.toml"]);
+    }
+
+    #[test]
+    fn defaults_for_an_empty_argv() {
+        assert_eq!(scan(&[]), ["./.dirsql.toml"]);
+    }
+
+    #[test]
+    fn treats_a_bare_trailing_long_config_as_an_empty_path() {
+        assert_eq!(scan(&["--config"]), [""]);
+    }
+
+    #[test]
+    fn treats_a_bare_trailing_short_c_as_an_empty_path() {
+        assert_eq!(scan(&["-c"]), [""]);
+    }
+
+    #[test]
+    fn keeps_a_bare_trailing_short_c_after_an_earlier_config() {
+        assert_eq!(scan(&["--config", "a.toml", "-c"]), ["a.toml", ""]);
+    }
+
+    #[test]
+    fn reads_an_empty_value_from_the_equals_forms() {
+        assert_eq!(scan(&["--config="]), [""]);
+        assert_eq!(scan(&["-c="]), [""]);
+    }
+
+    #[test]
+    fn does_not_treat_a_double_dash_as_end_of_options() {
+        assert_eq!(scan(&["--", "-c", "a.toml"]), ["a.toml"]);
+    }
+}

{dirsql-0.4.39 → dirsql-0.4.41}/packages/rust/src/lib.rs

@@ -20,6 +20,8 @@ pub mod functions;
 #[doc(hidden)]
 pub mod infer;
 #[doc(hidden)]
+pub mod launcher;
+#[doc(hidden)]
 pub mod matcher;
 #[doc(hidden)]
 pub mod parsed_cache;
@@ -538,6 +540,18 @@ impl DirSQL {
             return Vec::new();
         }
 
+        // A directory that appears whole (`mkdir`, or a populated directory
+        // renamed into the tree) arrives as one event naming the directory and
+        // none for the files already inside it, so the subtree is walked here.
+        // Only on creation: a metadata change on a directory says nothing
+        // about its files, and walking on every one would re-run `on_file`
+        // across the subtree for a `chmod`.
+        if matches!(event, FileEvent::Created(_))
+            && self.inner.fs.is_dir(&abs_path).unwrap_or(false)
+        {
+            return self.index_subtree(&abs_path);
+        }
+
         // Fan-out: dispatch the event to every table whose glob matches, and
         // concatenate the resulting row events. Cross-table event order is
         // unspecified. An `on_file` failure produces an error event for that
@@ -562,6 +576,27 @@ impl DirSQL {
         events
     }
 
+    /// Index every file beneath `dir` as if each had its own create event,
+    /// using the scanner's walk so the watch path and the initial scan share
+    /// one definition of what counts as a row.
+    fn index_subtree(&self, dir: &Path) -> Vec<RowEvent> {
+        let base = if dir.starts_with(&self.inner.watch_root) {
+            &self.inner.watch_root
+        } else {
+            &self.inner.root
+        };
+        let mut events = Vec::new();
+        for (path, table) in self.inner.fs.scan_subtree(base, dir, &self.inner.matcher) {
+            let rel_path = path
+                .strip_prefix(base)
+                .unwrap_or(&path)
+                .to_string_lossy()
+                .to_string();
+            events.extend(self.handle_upsert(&table, &path, &rel_path));
+        }
+        events
+    }
+
     fn handle_delete(&self, table: &str, rel_path: &str) -> Vec<RowEvent> {
         // Snapshot the file's rows before deleting them — the Delete events
         // carry the old-row payloads. Read and delete under one lock
@@ -1571,6 +1606,15 @@ trait FileSystem: Send + Sync {
     fn stat(&self, path: &Path) -> std::io::Result<FileStat>;
     /// Whether `path` is a regular file. `Err(NotFound)` when it doesn't exist.
     fn is_file(&self, path: &Path) -> std::io::Result<bool>;
+    /// Whether `path` is a directory. `Err(NotFound)` when it doesn't exist.
+    fn is_dir(&self, path: &Path) -> std::io::Result<bool>;
+    /// The scanner's walk over the subtree at `dir`, matched relative to `root`.
+    fn scan_subtree(
+        &self,
+        root: &Path,
+        dir: &Path,
+        matcher: &TableMatcher,
+    ) -> Vec<(PathBuf, String)>;
     /// BLAKE3-hash a file's contents.
     fn hash(&self, path: &Path) -> std::io::Result<[u8; 32]>;
     /// Canonicalize the watch root, falling back to the literal path.
@@ -1588,6 +1632,19 @@ impl FileSystem for RealFs {
         std::fs::metadata(path).map(|m| m.is_file())
     }
 
+    fn is_dir(&self, path: &Path) -> std::io::Result<bool> {
+        std::fs::metadata(path).map(|m| m.is_dir())
+    }
+
+    fn scan_subtree(
+        &self,
+        root: &Path,
+        dir: &Path,
+        matcher: &TableMatcher,
+    ) -> Vec<(PathBuf, String)> {
+        scanner::scan_subtree(root, dir, matcher)
+    }
+
     fn hash(&self, path: &Path) -> std::io::Result<[u8; 32]> {
         hash_file(path)
     }
@@ -2213,6 +2270,8 @@ mod internal_tests {
         hashes: StdHashMap<PathBuf, [u8; 32]>,
         canonical_roots: StdHashMap<PathBuf, String>,
         dirs: StdHashSet<PathBuf>,
+        subtrees: StdHashMap<PathBuf, Vec<(PathBuf, String)>>,
+        subtree_walks: Mutex<Vec<PathBuf>>,
     }
 
     impl FakeFs {
@@ -2228,6 +2287,22 @@ mod internal_tests {
             self
         }
 
+        /// Register a directory together with what the scanner's walk of it
+        /// would return; each file is also stat-able as a regular file.
+        fn with_subtree(mut self, dir: impl Into<PathBuf>, found: Vec<(PathBuf, String)>) -> Self {
+            let dir = dir.into();
+            self.dirs.insert(dir.clone());
+            for (path, _) in &found {
+                self.stats.insert(path.clone(), fake_stat());
+            }
+            self.subtrees.insert(dir, found);
+            self
+        }
+
+        fn subtree_walks(&self) -> Vec<PathBuf> {
+            self.subtree_walks.lock().unwrap().clone()
+        }
+
         fn set_hash(&mut self, path: impl Into<PathBuf>, hash: [u8; 32]) {
             self.hashes.insert(path.into(), hash);
         }
@@ -2263,6 +2338,29 @@ mod internal_tests {
             ))
         }
 
+        fn is_dir(&self, path: &Path) -> std::io::Result<bool> {
+            if self.dirs.contains(path) {
+                return Ok(true);
+            }
+            if self.stats.contains_key(path) {
+                return Ok(false);
+            }
+            Err(std::io::Error::new(
+                std::io::ErrorKind::NotFound,
+                "fake: no such file",
+            ))
+        }
+
+        fn scan_subtree(
+            &self,
+            _root: &Path,
+            dir: &Path,
+            _matcher: &TableMatcher,
+        ) -> Vec<(PathBuf, String)> {
+            self.subtree_walks.lock().unwrap().push(dir.to_path_buf());
+            self.subtrees.get(dir).cloned().unwrap_or_default()
+        }
+
         fn hash(&self, path: &Path) -> std::io::Result<[u8; 32]> {
             self.hashes.get(path).copied().ok_or_else(|| {
                 std::io::Error::new(std::io::ErrorKind::NotFound, "fake: no such file")
@@ -2517,6 +2615,144 @@ mod internal_tests {
         assert_eq!(events.len(), 1, "non-ignored path must produce one event");
     }
 
+    fn subtree_db(fake: FakeFs, root: &Path, ignore: Vec<&str>) -> DirSQL {
+        DirSQL::with_ignore_and_fs(
+            root,
+            vec![Table::new(
+                "items",
+                "CREATE TABLE items (name TEXT)",
+                "**/*.txt",
+                |path| {
+                    vec![Row::from_iter([(
+                        "name".to_string(),
+                        Value::Text(path.to_string()),
+                    )])]
+                },
+            )],
+            ignore,
+            Arc::new(fake),
+        )
+        .unwrap()
+    }
+
+    /// A created directory is indexed by walking it: every file the scanner
+    /// reports beneath it becomes rows, as if each had its own create event.
+    #[test]
+    fn process_file_event_indexes_the_files_beneath_a_created_directory() {
+        let dir = TempDir::new().unwrap();
+        let moved = dir.path().join("moved");
+        let a = moved.join("a.txt");
+        let deep = moved.join("one").join("deep.txt");
+        let fake = FakeFs::default().with_subtree(
+            moved.clone(),
+            vec![(a.clone(), "items".into()), (deep.clone(), "items".into())],
+        );
+        let db = subtree_db(fake, dir.path(), Vec::new());
+
+        let events = db.process_file_event(FileEvent::Created(moved));
+
+        assert_eq!(events.len(), 2, "one insert per file found: {events:?}");
+        assert!(
+            events.iter().all(|e| matches!(e, RowEvent::Insert { .. })),
+            "got: {events:?}"
+        );
+        let paths: Vec<String> = events
+            .iter()
+            .filter_map(|e| match e {
+                RowEvent::Insert { file_path, .. } => Some(file_path.clone()),
+                _ => None,
+            })
+            .collect();
+        assert_eq!(
+            paths,
+            vec!["moved/a.txt".to_string(), "moved/one/deep.txt".to_string()],
+            "file paths are root-relative"
+        );
+    }
+
+    /// The walk is matched against the root the event was stripped with, so
+    /// the rows it writes carry the same relative paths a create event would.
+    #[test]
+    fn process_file_event_walks_a_created_directory_under_the_watch_root() {
+        let root = PathBuf::from("/ws");
+        let moved = root.join("moved");
+        let fake = FakeFs::default()
+            .with_canonical_root(&root, "/ws")
+            .with_subtree(moved.clone(), vec![(moved.join("a.txt"), "items".into())]);
+        let db = subtree_db(fake, &root, Vec::new());
+
+        let events = db.process_file_event(FileEvent::Created(moved.clone()));
+
+        assert!(
+            matches!(&events[..], [RowEvent::Insert { file_path, .. }] if file_path == "moved/a.txt"),
+            "got: {events:?}"
+        );
+    }
+
+    /// Only a *created* directory is walked. A metadata change on one says
+    /// nothing about its files, and walking on every such event would re-run
+    /// `on_file` across the whole subtree for a `chmod`.
+    #[test]
+    fn process_file_event_does_not_walk_a_modified_directory() {
+        let dir = TempDir::new().unwrap();
+        let sub = dir.path().join("sub");
+        let fake =
+            FakeFs::default().with_subtree(sub.clone(), vec![(sub.join("a.txt"), "items".into())]);
+        let fake = Arc::new(fake);
+        let db = DirSQL::with_ignore_and_fs(
+            dir.path(),
+            vec![Table::new(
+                "items",
+                "CREATE TABLE items (name TEXT)",
+                "**/*.txt",
+                |_| vec![],
+            )],
+            Vec::<String>::new(),
+            fake.clone(),
+        )
+        .unwrap();
+
+        let events = db.process_file_event(FileEvent::Modified(sub.clone()));
+
+        assert!(events.is_empty(), "got: {events:?}");
+        assert!(
+            fake.subtree_walks().is_empty(),
+            "a modified directory must not be walked; walked: {:?}",
+            fake.subtree_walks()
+        );
+    }
+
+    /// An ignored directory is never walked, matching the initial scan.
+    #[test]
+    fn process_file_event_does_not_walk_an_ignored_created_directory() {
+        let dir = TempDir::new().unwrap();
+        let skip = dir.path().join("skip");
+        let fake = Arc::new(
+            FakeFs::default()
+                .with_subtree(skip.clone(), vec![(skip.join("a.txt"), "items".into())]),
+        );
+        let db = DirSQL::with_ignore_and_fs(
+            dir.path(),
+            vec![Table::new(
+                "items",
+                "CREATE TABLE items (name TEXT)",
+                "**/*.txt",
+                |_| vec![],
+            )],
+            vec!["skip"],
+            fake.clone(),
+        )
+        .unwrap();
+
+        let events = db.process_file_event(FileEvent::Created(skip));
+
+        assert!(events.is_empty(), "got: {events:?}");
+        assert!(
+            fake.subtree_walks().is_empty(),
+            "ignored directory was walked"
+        );
+    }
+
     /// Building with a **relative** root canonicalizes `watch_root` to an
     /// absolute path while leaving `root` exactly as the caller supplied it,
     /// so `notify` never sees `.`.
@@ -2773,6 +3009,19 @@ mod internal_tests {
             fs.is_file(&missing).is_err(),
             "is_file of a missing path must error"
         );
+        assert!(
+            fs.is_dir(dir.path()).unwrap(),
+            "a directory must report is_dir=true"
+        );
+        assert!(
+            fs.is_dir(&missing).is_err(),
+            "is_dir of a missing path must error"
+        );
+        let matcher = TableMatcher::new(&[("**/*", "files")], &[]).unwrap();
+        assert!(
+            fs.scan_subtree(dir.path(), dir.path(), &matcher).is_empty(),
+            "an empty directory walks to nothing"
+        );
         // A nonexistent path can't canonicalize, so the literal fallback runs.
         assert_eq!(
             fs.canonical_root(&missing),