dirsql 0.4.12__tar.gz → 0.4.14__tar.gz

{dirsql-0.4.12 → dirsql-0.4.14}/Cargo.lock

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

{dirsql-0.4.12 → dirsql-0.4.14}/Cargo.toml

@@ -33,18 +33,3 @@ futures-channel = "0.3"
 strip = "symbols"
 lto = "fat"
 codegen-units = 1
-
-[workspace.lints.rust]
-unsafe_code = "forbid"
-rust_2018_idioms = { level = "warn", priority = -1 }
-
-[workspace.lints.clippy]
-# Broad groups kept at `warn` so CI can catch regressions without
-# becoming hostile to contributors; upgrade to `deny` in CI if desired.
-all = { level = "warn", priority = -1 }
-pedantic = { level = "warn", priority = -1 }
-# Opinionated opt-outs from pedantic: too noisy vs. useful here.
-module_name_repetitions = "allow"
-missing_errors_doc = "allow"
-missing_panics_doc = "allow"
-must_use_candidate = "allow"

{dirsql-0.4.12 → dirsql-0.4.14}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.12
+Version: 0.4.14
 Requires-Dist: tomli>=2 ; python_full_version < '3.11'
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index

{dirsql-0.4.12 → dirsql-0.4.14}/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.12"
+version = "0.4.14"
 # 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
@@ -25,17 +25,22 @@ crate-type = ["cdylib", "rlib"]
 dirsql.workspace = true
 pyo3 = { version = "0.28", features = ["extension-module", "generate-import-lib", "abi3-py310"], optional = true }
 
-# Opted in per-crate rather than via `[lints] workspace = true`: the workspace
-# block also carries `clippy::pedantic`, which currently reports 475 warnings
-# across the three crates and would fail `clippy -D warnings` immediately
-# (#763).
-#
-# `deny`, not the workspace's aspirational `forbid`: pyo3's proc macros emit `#[allow(unsafe_code)]`, which `forbid`
-# rejects outright (E0453).
-# `deny` still blocks new hand-written `unsafe` unless a site opts in
-# explicitly, which is the guarantee we want.
 [lints.rust]
+# `deny`, not `forbid`: pyo3's proc macros emit `#[allow(unsafe_code)]`, which
+# `forbid` rejects outright (E0453). `deny` still blocks new hand-written
+# `unsafe` unless a site opts in explicitly, which is the guarantee we want.
 unsafe_code = "deny"
+rust_2018_idioms = { level = "warn", priority = -1 }
+
+# The narrow slice of clippy::pedantic worth enforcing (#763); mirrors the
+# core crate's block. No sites in this crate today -- the value is catching
+# future lossy casts at the binding boundary.
+[lints.clippy]
+cast_lossless = "warn"
+cast_possible_truncation = "warn"
+cast_possible_wrap = "warn"
+cast_precision_loss = "warn"
+cast_sign_loss = "warn"
 
 [features]
 default = []

dirsql-0.4.14/packages/python/changelog.d/2026-08-04-cast-lints.md

@@ -0,0 +1 @@
+**Changed** — the pyo3 binding crate now enforces the clippy cast lints (`cast_lossless`, `cast_possible_truncation`, `cast_possible_wrap`, `cast_precision_loss`, `cast_sign_loss`) via `[lints.clippy]`, so a future lossy numeric cast at the binding boundary fails the build. No code changes were needed; no observable behavior change.

dirsql-0.4.14/packages/python/e2e-attestations/chore-766-narrow-pedantic.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1785867315,
+  "exit_code": 0,
+  "commit": "48dbead65b0060f7ee5cad2e0db969467febbaf3",
+  "branch": "chore/766-narrow-pedantic"
+}

dirsql-0.4.14/packages/python/e2e-attestations/claude-772-extension-without-config.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1785877241,
+  "exit_code": 0,
+  "commit": "83f767a7d90cefe1aa6ab136e36a739cfb5dc425",
+  "branch": "claude/772-extension-without-config"
+}

{dirsql-0.4.12 → dirsql-0.4.14}/packages/rust/Cargo.toml

@@ -74,11 +74,6 @@ toml = "0.8"
 wait-timeout = "0.2"
 walkdir = "2"
 
-# Opted in per-crate rather than via `[lints] workspace = true`: the workspace
-# block also carries `clippy::pedantic`, which currently reports 475 warnings
-# across the three crates and would fail `clippy -D warnings` immediately
-# (#763). This is the lint whose absence actually mattered -- it forbids
-# nothing until a crate opts in.
 [lints.rust]
 # `deny`, not `forbid`: rusqlite's API imposes five unavoidable `unsafe`
 # sites (the `load_extension` guard and four `unsafe impl VTab`/`VTabCursor`).
@@ -87,6 +82,19 @@ walkdir = "2"
 # with `#[expect(unsafe_code, reason = ...)]`, which is the guarantee we
 # actually want (#763).
 unsafe_code = "deny"
+rust_2018_idioms = { level = "warn", priority = -1 }
+
+# The narrow slice of clippy::pedantic worth enforcing (#763): dirsql marshals
+# sizes, timestamps, and row indexes between usize/u64 and SQLite's i64, where
+# a silent lossy cast corrupts data. The rest of pedantic is style noise here
+# and stays off. Intentional lossy/bit-preserving casts opt out per-site with
+# `#[expect(clippy::cast_..., reason = ...)]`.
+[lints.clippy]
+cast_lossless = "warn"
+cast_possible_truncation = "warn"
+cast_possible_wrap = "warn"
+cast_precision_loss = "warn"
+cast_sign_loss = "warn"
 
 [[bin]]
 name = "dirsql"

{dirsql-0.4.12 → dirsql-0.4.14}/packages/rust/benches/db_bench.rs

@@ -1,3 +1,9 @@
+#![expect(
+    clippy::cast_possible_wrap,
+    clippy::cast_precision_loss,
+    reason = "bench fixture indices are small; the casts are exact"
+)]
+
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use dirsql::db::{Db, Value};
 use std::collections::HashMap;

{dirsql-0.4.12 → dirsql-0.4.14}/packages/rust/benches/differ_bench.rs

@@ -1,3 +1,9 @@
+#![expect(
+    clippy::cast_possible_wrap,
+    clippy::cast_precision_loss,
+    reason = "bench fixture indices are small; the casts are exact"
+)]
+
 use criterion::{BenchmarkId, Criterion, criterion_group, criterion_main};
 use dirsql::db::Value;
 use dirsql::differ::diff;

dirsql-0.4.14/packages/rust/changelog.d/2026-08-04-cast-lints.md

@@ -0,0 +1 @@
+**Changed** — lossy numeric casts are now compile errors: the crate enforces the clippy cast lints (`cast_lossless`, `cast_possible_truncation`, `cast_possible_wrap`, `cast_precision_loss`, `cast_sign_loss`) via `[lints.clippy]`. Existing size/timestamp/row-index conversions were rewritten as checked `try_from` conversions (no observable behavior change); the intentional inode/device bit-pattern casts are documented with `#[expect]`. The never-enforced `clippy::pedantic` block was removed from `[workspace.lints]`.

dirsql-0.4.14/packages/rust/changelog.d/2026-08-04-configless-extension.md

@@ -0,0 +1 @@
+**Fixed** — `--extension` is now honored when no `-c`/`--config` is given. The configless path (no config, no `--include-default`) short-circuited before extensions were applied, so `dirsql query "SELECT vec_version()" --extension <path>::<entry>` reported `no such function: vec_version` as though the flag had not been passed — and, worse, `--extension /nonexistent.so` exited **0**, silently succeeding on a load that never happened. Both now behave: the extension loads and a bad path fails with `failed to build the index: failed to load extension '<path>'` and exit 1, matching the with-config path. This mattered because loading an extension to query a path-table (`SELECT * FROM './'`) needs no config at all, and because the npm/pip launchers pass resolved `--extension` flags — a launcher-resolved extension was dropped whenever the user had no config. #772.

{dirsql-0.4.12 → dirsql-0.4.14}/packages/rust/src/bin/dirsql.rs

@@ -581,6 +581,15 @@ fn load_configless_state(cfg: &ConfigArgs, path_table_parser: Option<String>) ->
     };
 
     let mut builder = cfg.apply_index_flags(DirSQL::builder().root(root));
+    // `--extension` applies here too (#772). Without this the flag was
+    // silently ignored whenever no `-c` was given: `dirsql query "SELECT
+    // vec_version()" --extension <path>` reported `no such function` rather
+    // than loading anything, and `--extension /nonexistent.so` exited 0. A
+    // path-table query over an extension-provided function is a legitimate
+    // configless use, and a bad path must still fail loudly.
+    if !cfg.extension.is_empty() {
+        builder = builder.extensions(parse_extension_specs(&cfg.extension));
+    }
     if let Some(command) = path_table_parser {
         builder = builder.path_table_parser(command);
     }
@@ -932,6 +941,31 @@ mod tests {
         );
     }
 
+    #[test]
+    fn configless_state_still_carries_extension_specs() {
+        // `--extension` with no `-c` took the configless path, which never
+        // applied the specs: the flag was silently ignored and a bad path
+        // exited 0 (#772). Parsing is the seam a unit test can reach; the
+        // load itself needs a real SQLite handle and is covered at the
+        // integration tier.
+        let cfg = ConfigArgs {
+            config: Vec::new(),
+            include_default: false,
+            extension: vec!["/ext/vec0.so::sqlite3_vec_init".to_string()],
+            persist: None,
+            no_ignore: false,
+        };
+        assert!(cfg.config.is_empty(), "this is the configless shape");
+        assert!(
+            !cfg.extension.is_empty(),
+            "and it still carries an extension"
+        );
+        let specs = parse_extension_specs(&cfg.extension);
+        assert_eq!(specs.len(), 1);
+        assert_eq!(specs[0].path, PathBuf::from("/ext/vec0.so"));
+        assert_eq!(specs[0].entrypoint.as_deref(), Some("sqlite3_vec_init"));
+    }
+
     #[test]
     fn parse_extension_specs_handles_bare_path_and_entrypoint() {
         let specs = vec![

{dirsql-0.4.12 → dirsql-0.4.14}/packages/rust/src/config.rs

@@ -358,7 +358,9 @@ pub fn load_config_str(content: &str) -> Result<Config> {
 fn parse_timeout_secs(field: &'static str, raw: Option<i64>) -> Result<Option<Duration>> {
     match raw {
         Some(secs) if secs <= 0 => Err(ConfigError::InvalidTimeout { field, value: secs }),
-        Some(secs) => Ok(Some(Duration::from_secs(secs as u64))),
+        Some(secs) => Ok(Some(Duration::from_secs(
+            u64::try_from(secs).expect("non-positive values rejected above"),
+        ))),
         None => Ok(None),
     }
 }

{dirsql-0.4.12 → dirsql-0.4.14}/packages/rust/src/db.rs

@@ -465,7 +465,12 @@ impl Db {
         conn.execute(
             "INSERT INTO _dirsql_internal_rows (table_name, file_path, row_index, rowid_ref) \
              VALUES (?1, ?2, ?3, ?4)",
-            rusqlite::params![table, file_path, row_index as i64, rowid],
+            rusqlite::params![
+                table,
+                file_path,
+                i64::try_from(row_index).expect("row index fits in i64"),
+                rowid
+            ],
         )?;
         Ok(())
     }
@@ -1054,7 +1059,7 @@ mod tests {
         for (i, action) in ["created", "resolved", "reopened"].iter().enumerate() {
             let row = HashMap::from([
                 ("action".into(), Value::Text(action.to_string())),
-                ("ts".into(), Value::Integer(i as i64)),
+                ("ts".into(), Value::Integer(i64::try_from(i).unwrap())),
             ]);
             db.insert_row("events", &row, "thread.jsonl", i).unwrap();
         }

{dirsql-0.4.12 → dirsql-0.4.14}/packages/rust/src/lib.rs

@@ -1692,10 +1692,10 @@ pub(crate) fn compute_stat_virtuals(rel_path: &str, abs_path: &Path) -> Row {
             let to_secs = |t: std::io::Result<std::time::SystemTime>| {
                 t.ok()
                     .and_then(|st| st.duration_since(std::time::UNIX_EPOCH).ok())
-                    .map(|d| d.as_secs() as i64)
+                    .and_then(|d| i64::try_from(d.as_secs()).ok())
             };
             (
-                Some(metadata.len() as i64),
+                i64::try_from(metadata.len()).ok(),
                 to_secs(metadata.modified()),
                 to_secs(metadata.created()),
             )

{dirsql-0.4.12 → dirsql-0.4.14}/packages/rust/src/persist.rs

@@ -60,7 +60,7 @@ impl FileStat {
         let ctime_ns = system_time_to_ns(meta.created().ok());
         let (inode, dev) = inode_dev(meta);
         Self {
-            size: meta.len() as i64,
+            size: i64::try_from(meta.len()).expect("file size fits in i64"),
             mtime_ns,
             ctime_ns,
             inode,
@@ -70,6 +70,10 @@ impl FileStat {
 }
 
 #[cfg(unix)]
+#[expect(
+    clippy::cast_possible_wrap,
+    reason = "inode/device numbers are opaque bit patterns; wrapping reinterpretation is intended"
+)]
 fn inode_dev(meta: &fs::Metadata) -> (i64, i64) {
     use std::os::unix::fs::MetadataExt;
     (meta.ino() as i64, meta.dev() as i64)

dirsql-0.4.12/packages/python/e2e-attestations/claude-763-forbid-unsafe.json

@@ -1,7 +0,0 @@
-{
-  "command": "uv run python -m pytest tests/e2e/ -x -q",
-  "ran_at": 1785791343,
-  "exit_code": 0,
-  "commit": "b1b8d2b6b2a200ba4d4aa844221dd7b8e85da92c",
-  "branch": "claude/763-forbid-unsafe"
-}

dirsql-0.4.12/packages/python/e2e-attestations/feat-745-python-no-ignore.json

@@ -1,7 +0,0 @@
-{
-  "command": "just test-e2e",
-  "ran_at": 1785777931,
-  "exit_code": 0,
-  "commit": "ef9db367f3a4979a0006e7bd40b0808f433b26ee",
-  "branch": "feat/745-python-no-ignore"
-}

dirsql-0.4.12/packages/python/e2e-attestations/fix-754-discovery-ext-resolution.json

@@ -1,7 +0,0 @@
-{
-  "command": "just test-e2e",
-  "ran_at": 1785779409,
-  "exit_code": 0,
-  "commit": "610d8ff41538de6e3d5f19b4abea3ec1b351986a",
-  "branch": "fix/754-discovery-ext-resolution"
-}