dirsql 0.4.40__tar.gz → 0.4.41__tar.gz

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

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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.40
+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.40 → 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.40 → 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.40 → 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.40"
+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.40 → 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.40 → 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.40"
+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.40 → 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;

dirsql-0.4.40/dirsql/cli/config_paths_from_argv.py

@@ -1,28 +0,0 @@
-"""Config-path extraction from the launcher's argv.
-
-Every config flag occurrence counts -- ``-c``/``--config`` are repeatable,
-and plugin discovery injects fragments as additional ``-c`` flags -- so the
-scan collects them all, in argv order.
-"""
-
-from __future__ import annotations
-
-
-def config_paths_from_argv(argv: list[str]) -> list[str]:
-    """Every config value in argv, in order (``--config X``, ``--config=X``,
-    ``-c X``, ``-c=X``, ``-cX``), or the default when none are given."""
-    paths: list[str] = []
-    i = 0
-    while i < len(argv):
-        a = argv[i]
-        if a == "--config" or a == "-c":
-            # A bare trailing flag (no following value) yields "".
-            paths.append(next(iter(argv[i + 1 :]), ""))
-            i += 2
-            continue
-        if a.startswith("--config="):
-            paths.append(a[len("--config=") :])
-        elif a.startswith("-c"):
-            paths.append(a[len("-c") :].removeprefix("="))
-        i += 1
-    return paths or ["./.dirsql.toml"]