dirsql 0.3.71__tar.gz → 0.3.72__tar.gz

{dirsql-0.3.71 → dirsql-0.3.72}/Cargo.lock

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

{dirsql-0.3.71 → dirsql-0.3.72}/PKG-INFO

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

{dirsql-0.3.71 → dirsql-0.3.72}/dirsql/_async.py

@@ -59,7 +59,7 @@ class DirSQL:
     at startup. Any ``[[dirsql.extension]]`` entries in a ``config`` file are
     appended after the programmatic ones. A ``path`` (programmatic or
     config-file) may be a bare **package name**, resolved from the installed
-    package in the runtime env (#298 / #313).
+    package in the runtime env.
     """
 
     def __init__(
@@ -98,15 +98,13 @@ class DirSQL:
         """Resolve extensions and construct the Rust-backed instance.
 
         Runs on a worker thread (via ``asyncio.to_thread``): both the
-        package-name resolution (``importlib`` + filesystem globs) and the
-        core's initial scan are blocking work.
+        package-name resolution and the core's initial scan are blocking.
 
         When the ``config`` file names an extension by bare package name, the
         SDK resolves every one of the config's ``[[dirsql.extension]]`` entries
-        itself (#313) -- appended after the programmatic ones, matching the
-        core's ordering -- and suppresses the core's own config-extension
-        loading so the entries are not loaded a second time (and the core never
-        sees the unresolvable bare name).
+        itself -- appended after the programmatic ones -- and suppresses the
+        core's own config-extension loading so the entries are not loaded a
+        second time (the core cannot resolve a bare name).
         """
         extensions = self._resolved_extensions()
         suppress = False
@@ -129,9 +127,8 @@ class DirSQL:
     def _resolved_extensions(self):
         """Resolve each programmatic extension's ``path`` to a loadable file.
 
-        A bare package name is resolved to the loadable installed in the runtime
-        env (#298); path-looking values are passed through verbatim (mirroring
-        the Rust builder, which takes programmatic paths as-is). Config-file
+        A bare package name is resolved to the loadable installed in the
+        runtime env; path-looking values pass through verbatim. Config-file
         ``[[dirsql.extension]]`` entries are handled by ``_build_db``.
         """
         if not self._extensions:

{dirsql-0.3.71 → dirsql-0.3.72}/dirsql/cli/main.py

@@ -24,7 +24,7 @@ def main(argv: list[str] | None = None) -> int:
         return 1
 
     # Resolve any package-name extensions in a TOML config here (the binary
-    # can't) and pass them as `--extension` flags; a no-op otherwise (#227).
+    # can't) and pass them as `--extension` flags; a no-op otherwise.
     try:
         argv = with_resolved_extensions(argv)
     except Exception as exc:

{dirsql-0.3.71 → dirsql-0.3.72}/dirsql/cli/resolve_config_extensions.py

@@ -1,14 +1,12 @@
 """Launcher-side resolution of a TOML config's ``[[dirsql.extension]]`` entries.
 
-Mirrors the TypeScript launcher. The compiled ``dirsql`` binary reads a
-``.dirsql.toml`` itself and loads its extensions literally -- it has no
-``importlib``, so it cannot resolve a bare **package name** (#227). This
-launcher can. When a TOML config names an extension by package name, the
-shared SDK resolver (:mod:`dirsql.resolve_config_extensions`, #313) resolves
-every one of its extensions and this launcher passes the resolved literal
-paths to the binary via repeatable ``--extension`` flags; the binary then
-loads those and ignores the config's own extension entries (the Rust
-``--extension`` flag / ``suppress_config_extensions``).
+The compiled ``dirsql`` binary loads a config's extensions literally -- it
+has no ``importlib``, so it cannot resolve a bare **package name**. When a
+TOML config names an extension by package name, the shared SDK resolver
+(:mod:`dirsql.resolve_config_extensions`) resolves every one of its
+extensions and this launcher passes the resolved literal paths to the binary
+via repeatable ``--extension`` flags; the binary then loads those and ignores
+the config's own extension entries.
 
 Native-language configs (``.py`` / ``.js`` / ``.mjs`` / ``.cjs``) are untouched:
 the binary dispatches those to ``dirsql interpret``, whose handshake already

{dirsql-0.3.71 → dirsql-0.3.72}/dirsql/resolve_config_extensions.py

@@ -1,16 +1,14 @@
 """SDK-side resolution of a TOML config's ``[[dirsql.extension]]`` entries.
 
-The Rust core parses a ``.dirsql.toml`` itself and loads its extensions
-literally -- it has no ``importlib``, so it cannot resolve a bare **package
-name** (#227). The SDK can (#313). When a TOML config names an extension by
-package name, the SDK resolves every one of its extensions here, hands the
-core the resolved literal paths, and suppresses the core's own config-extension
-loading (the Rust ``suppress_config_extensions`` builder toggle) so the
-config's entries are not loaded a second time.
+The Rust core loads a config's extensions literally -- it has no
+``importlib``, so it cannot resolve a bare **package name**. When a TOML
+config names an extension by package name, the SDK resolves every one of its
+extensions here, hands the core the resolved literal paths, and suppresses
+the core's own config-extension loading (``suppress_config_extensions``) so
+the config's entries are not loaded a second time.
 
 Shared by the ``DirSQL`` constructor (``config=`` path) and the CLI launcher
-(``dirsql.cli.resolve_config_extensions``, which converts the resolved specs
-into ``--extension`` flags for the binary).
+(which converts the resolved specs into ``--extension`` flags).
 """
 
 from __future__ import annotations
@@ -45,9 +43,7 @@ def resolve_config_extension_specs(config_path):
     entries = cfg.get("extension")
     if not isinstance(entries, list):
         return None
-    # Only intervene when at least one path is a bare package name; a config
-    # with only literal paths (or no entries at all) keeps the core's existing
-    # behavior untouched.
+    # Only intervene when at least one path is a bare package name.
     if not any(
         isinstance(e, dict)
         and isinstance(e.get("path"), str)

{dirsql-0.3.71 → dirsql-0.3.72}/dirsql/resolve_extension.py

@@ -1,23 +1,17 @@
 """Resolve an extension entry's ``path`` to a concrete loadable file.
 
-#225 supports only literal file paths. #298 adds resolving a bare **package
-name**: when ``path`` carries no path separator and no loadable-file suffix, it
-names a package installed in the runtime env, and dirsql discovers the loadable
-file *inside* that package.
-
-Resolution is an ordered probe (file-first, then package), so every literal
-path from #225 keeps its old behavior and only a bare name reaches the package
-machinery:
+Resolution is an ordered probe (file-first, then package), so only a bare
+package name reaches the package machinery:
 
 1. **Path-looking** (contains a separator, or ends in ``.so`` / ``.dylib`` /
    ``.dll`` / ``.pyd``) -- returned as a file path: made absolute against
    ``base`` when ``resolve_relative`` is set (config-file entries), else
-   verbatim (programmatic entries, mirroring the Rust builder).
+   verbatim (programmatic entries).
 2. **Bare name** -- a same-named local file under ``base`` *shadows* the
-   package (parity with #225's file-first probe); otherwise the package dir is
-   located via :func:`importlib.util.find_spec` and the current platform's
-   loadable is globbed from inside it. Zero matches and multiple matches are
-   both hard errors -- the caller must disambiguate with a literal path.
+   package; otherwise the package dir is located via
+   :func:`importlib.util.find_spec` and the current platform's loadable is
+   globbed from inside it. Zero matches and multiple matches are both hard
+   errors -- the caller must disambiguate with a literal path.
 """
 
 import glob as _glob
@@ -25,9 +19,8 @@ import importlib.util
 import os
 import sys
 
-# Suffixes that mark a value as "already a file path" (so package resolution is
-# never attempted) and, per platform, the globs used to find a loadable inside
-# a package directory.
+# Suffixes that mark a value as "already a file path", so package resolution
+# is never attempted.
 _LOADABLE_SUFFIXES = (".so", ".dylib", ".dll", ".pyd")
 
 
@@ -73,8 +66,6 @@ def _resolve_package(name):
             matches.update(_glob.glob(os.path.join(d, "**", pat), recursive=True))
     found = sorted(matches)
 
-    # Exactly one loadable resolves; unpacking (rather than a guarded
-    # subscript) makes the zero- and multiple-match failures each observable.
     try:
         (single,) = found
     except ValueError:

{dirsql-0.3.71 → dirsql-0.3.72}/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.71"
+version = "0.3.72"
 edition.workspace = true
 publish = false
 readme = "README.md"

{dirsql-0.3.71 → dirsql-0.3.72}/packages/python/conftest.py

@@ -1,15 +1,9 @@
 """Stub the compiled `_dirsql` extension for unit tests that don't need it.
 
-`cli_test.py` exercises the pure-Python launcher; it must be runnable
-without `maturin develop` having built the PyO3 extension. We stub the
-missing module here (rather than in the test file) so the stub is in
-place before pytest imports `dirsql.__init__`, which transitively
-imports real types from `dirsql._dirsql`.
-
-The stub is installed ONLY when the real extension can't be imported.
-When `maturin develop` has been run (as in CI), the real extension wins
-and tests that depend on it — `_async_test.py`, the integration suites —
-see the real bindings.
+Must live here (not in a test file) so the stub is in place before pytest
+imports `dirsql.__init__`, which imports real types from `dirsql._dirsql`.
+Installed only when the real extension can't be imported; when `maturin
+develop` has been run, the real bindings win.
 """
 
 from __future__ import annotations

{dirsql-0.3.71 → dirsql-0.3.72}/packages/python/e2e-attestation.json

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

{dirsql-0.3.71 → dirsql-0.3.72}/packages/python/src/lib.rs

@@ -20,8 +20,6 @@ mod python {
     use std::path::PathBuf;
     use std::time::Duration;
 
-    // -- Public PyO3 classes ------------------------------------------------
-
     /// A table definition. Mirrors `dirsql::Table` but holds a Python
     /// callable for `extract`.
     #[pyclass(name = "Table", frozen)]
@@ -34,15 +32,11 @@ mod python {
         extract: Py<PyAny>,
         #[pyo3(get)]
         strict: bool,
-        /// Parsed table name (from `ddl`), or `None` if the DDL doesn't
-        /// match `CREATE TABLE <name> (...)`. Computed once at construction
-        /// via `dirsql::db::parse_table_name` so the `dirsql interpret`
-        /// dispatcher (#196) and other consumers share the core's single
-        /// source of truth instead of re-parsing DDL. We return `None`
-        /// rather than raising at construction so `DirSQL.ready()` keeps
-        /// surfacing malformed DDLs as the loud failure path (the Rust
-        /// core's `DirSqlError::Ddl`); callers that care about the name
-        /// before that point can check `t.name is None` themselves.
+        /// Parsed table name (from `ddl`) via `dirsql::db::parse_table_name`,
+        /// or `None` if the DDL doesn't match `CREATE TABLE <name> (...)`.
+        /// `None` rather than a construction error so `DirSQL.ready()` keeps
+        /// surfacing malformed DDLs as the loud failure path (the core's
+        /// `DirSqlError::Ddl`).
         #[pyo3(get)]
         name: Option<String>,
     }
@@ -64,11 +58,9 @@ mod python {
     }
 
     /// Marshals a Python `{"path": str, "entrypoint"?: str}` mapping from the
-    /// `extensions=` constructor argument into a [`dirsql::Extension`]. Mirrors
-    /// the `[[dirsql.extension]]` config-file fields and the Rust builder's
-    /// `Extension { path, entrypoint }`. Paths are taken verbatim (the
-    /// programmatic surface does not resolve relative paths), matching
-    /// `DirSQLBuilder::extensions`.
+    /// `extensions=` constructor argument into a [`dirsql::Extension`]. Paths
+    /// are taken verbatim; the programmatic surface does not resolve relative
+    /// paths.
     #[derive(FromPyObject)]
     struct PyExtensionSpec {
         #[pyo3(item)]
@@ -117,8 +109,8 @@ mod python {
         /// `suppress_config_extensions` skips the core's own loading of the
         /// config's `[[dirsql.extension]]` entries; the SDK sets it after
         /// resolving those entries itself (package names need `importlib`,
-        /// which the core lacks -- #313) and passing the resolved literal
-        /// paths via `extensions`, so the entries are not loaded twice.
+        /// which the core lacks) and passing the resolved literal paths via
+        /// `extensions`, so the entries are not loaded twice.
         #[new]
         #[pyo3(signature = (root=None, *, tables=None, ignore=None, config=None, persist=false, persist_path=None, extensions=None, suppress_config_extensions=false))]
         fn new(
@@ -205,8 +197,6 @@ mod python {
         }
     }
 
-    // -- Helpers ------------------------------------------------------------
-
     fn build_table(py: Python<'_>, t: &PyTable) -> Table {
         let extract_ref = t.extract.clone_ref(py);
         let mut table = Table::try_new(
@@ -260,10 +250,7 @@ mod python {
     /// Pure, GIL-free intermediate for a row event. [`row_event_to_plain`]
     /// builds it from a core [`RowEvent`] (unit-testable without a Python
     /// interpreter); [`row_event_to_py`] then marshals it into the
-    /// Python-facing [`PyRowEvent`] (the GIL step). Splitting the two keeps the
-    /// variant -> action / field-selection mapping testable at the unit tier,
-    /// mirroring the napi binding's pure `row_event_to_js`. The value-level
-    /// `Row -> PyDict` conversion stays GIL-bound (binding-tier covered).
+    /// Python-facing [`PyRowEvent`] (the GIL step).
     struct PlainRowEvent {
         table: Option<String>,
         action: &'static str,
@@ -406,8 +393,6 @@ mod python {
         }
     }
 
-    // -- Module registration ------------------------------------------------
-
     #[pymodule]
     #[pyo3(name = "_dirsql")]
     fn py_dirsql_module(m: &Bound<'_, PyModule>) -> PyResult<()> {

{dirsql-0.3.71 → dirsql-0.3.72}/packages/python/tests/conftest.py

@@ -15,7 +15,6 @@ def tmp_dir():
 @pytest.fixture
 def jsonl_dir(tmp_dir):
     """Create a temp dir with JSONL files for testing."""
-    # Create a simple JSONL file
     os.makedirs(os.path.join(tmp_dir, "comments", "abc"), exist_ok=True)
     os.makedirs(os.path.join(tmp_dir, "comments", "def"), exist_ok=True)
 

{dirsql-0.3.71 → dirsql-0.3.72}/packages/rust/benches/differ_bench.rs

@@ -46,7 +46,6 @@ fn bench_diff_single_line_change(c: &mut Criterion) {
     for count in [10, 100, 1000] {
         let old = make_rows(count);
         let mut new = old.clone();
-        // Change one row in the middle
         new[count / 2].insert("name".to_string(), Value::Text("CHANGED".to_string()));
         group.bench_with_input(BenchmarkId::from_parameter(count), &count, |b, _| {
             b.iter(|| {
@@ -62,7 +61,6 @@ fn bench_diff_append(c: &mut Criterion) {
     for count in [10, 100, 1000] {
         let old = make_rows(count);
         let mut new = old.clone();
-        // Append 10% more rows
         let extra = make_rows(count + count / 10);
         new.extend_from_slice(&extra[count..]);
         group.bench_with_input(BenchmarkId::from_parameter(count), &count, |b, _| {
@@ -78,7 +76,6 @@ fn bench_diff_full_replace(c: &mut Criterion) {
     let mut group = c.benchmark_group("differ/full_replace");
     for count in [10, 100, 1000] {
         let old = make_rows(count);
-        // Completely different rows trigger full replace
         let new: Vec<HashMap<String, Value>> = (0..count)
             .map(|i| {
                 HashMap::from([

{dirsql-0.3.71 → dirsql-0.3.72}/packages/rust/benches/scanner_bench.rs

@@ -7,7 +7,6 @@ use tempfile::TempDir;
 fn create_temp_tree(file_count: usize) -> TempDir {
     let dir = TempDir::new().unwrap();
     for i in 0..file_count {
-        // Distribute files across subdirectories
         let subdir = dir.path().join(format!("dir_{}", i % 10));
         fs::create_dir_all(&subdir).unwrap();
         fs::write(
@@ -16,7 +15,6 @@ fn create_temp_tree(file_count: usize) -> TempDir {
         )
         .unwrap();
     }
-    // Add some non-matching files
     for i in 0..file_count / 5 {
         fs::write(dir.path().join(format!("readme_{i}.md")), "# not matched").unwrap();
     }

{dirsql-0.3.71 → dirsql-0.3.72}/packages/rust/src/bin/dirsql.rs

@@ -53,8 +53,8 @@ struct Cli {
     ///
     /// Intended for the language launcher (pip/npm), not end users: the
     /// launcher resolves config extensions — including bare **package names**,
-    /// which need an interpreter this compiled binary lacks (see #227) — and
-    /// passes the resolved literal paths here. When any are present, the TOML
+    /// which need an interpreter this compiled binary lacks — and passes the
+    /// resolved literal paths here. When any are present, the TOML
     /// config's own extension entries are not loaded (the launcher already
     /// merged and resolved them). Used by server mode and by the `query`
     /// subcommand.
@@ -198,7 +198,6 @@ async fn run_server(cli: Cli) -> ExitCode {
     // Echo back the user-facing hostname (not the resolved IP SocketAddr).
     println!("Running at {host}:{}", handle.local_addr().port());
 
-    // Await ctrl-c / SIGTERM; then drain.
     if let Err(err) = wait_for_shutdown().await {
         eprintln!("dirsql: signal handler error: {err}");
     }
@@ -233,9 +232,9 @@ fn load_state(cli: &Cli) -> AppState {
 
     // Launcher-resolved extensions (`--extension`) override the TOML config's
     // own `[[dirsql.extension]]` entries: the launcher has already merged and
-    // resolved them (including package names the compiled binary can't resolve;
-    // #227), so build from the config but suppress its extension loading and
-    // supply the resolved literal paths instead.
+    // resolved them (including package names the compiled binary can't
+    // resolve), so suppress the config's extension loading and supply the
+    // resolved literal paths instead.
     let build = if cli.extension.is_empty() {
         DirSQL::from_config_path(&resolved)
     } else {
@@ -428,10 +427,6 @@ mod tests {
 
     #[test]
     fn default_files_table_declares_filesystem_fact_columns_over_recursive_glob() {
-        // The zero-config fallback table is pure data: a fixed DDL naming only
-        // the auto-injected filesystem-fact columns and a `**/*` glob that
-        // matches every file at any depth. The extract closure is never
-        // invoked here, so this stays a pure unit test.
         let table = default_files_table();
         assert_eq!(table.glob, "**/*");
         assert!(table.ddl.starts_with("CREATE TABLE files ("));

{dirsql-0.3.71 → dirsql-0.3.72}/packages/rust/src/cli/execute.rs

@@ -4,7 +4,7 @@
 //! the `pre-query` hook, the query timeout, [`DirSQL::query`], row
 //! serialization, the `post-query` hook, and error classification —
 //! lives here exactly once. The HTTP handler and the one-shot
-//! `dirsql query` subcommand (#399) are thin transport adapters over
+//! `dirsql query` subcommand are thin transport adapters over
 //! [`execute_query`], so the two surfaces cannot drift behaviorally:
 //! per-surface code only maps [`QueryFailure`] to a status code or an
 //! exit code.

{dirsql-0.3.71 → dirsql-0.3.72}/packages/rust/src/cli/init.rs

@@ -9,7 +9,7 @@
 //!
 //! Failure modes:
 //! - Output already exists and `--force` was not passed: bail before
-//!   spawning the agent (no point burning a paid LLM call).
+//!   spawning the agent (never burn a paid LLM call first).
 //! - `claude` is not on PATH: surface a descriptive error pointing at
 //!   the install docs.
 //! - `claude` exits non-zero: surface its stderr; do not write any
@@ -150,8 +150,7 @@ mod tests {
         assert!(msg.contains("claude"));
     }
 
-    /// `run` bails before spawning the agent when the output already exists and
-    /// `--force` was not passed (the temp dir itself is an existing path).
+    /// The temp dir itself serves as the already-existing output path.
     #[test]
     fn run_bails_when_output_exists_without_force() {
         let dir = tempfile::tempdir().unwrap();
@@ -167,10 +166,9 @@ mod tests {
         );
     }
 
-    // The spawn / non-zero-exit / write failure arms of `run` require actually
-    // invoking `claude` and touching the filesystem, so they are exercised at
-    // the e2e tier. Their `Display` renderings, however, are pure and covered
-    // here (the values are constructed inline, no process or fs I/O).
+    // The spawn / non-zero-exit / write failure arms of `run` need a real
+    // `claude` and filesystem, so they live at the e2e tier; only their pure
+    // `Display` renderings are covered here.
 
     #[test]
     fn spawn_error_display_mentions_spawn() {
@@ -196,8 +194,6 @@ mod tests {
 
     #[test]
     fn invalid_utf8_error_display_mentions_utf8() {
-        // A non-UTF8 byte sequence yields the `FromUtf8Error` that `#[from]`
-        // converts into `InitError::InvalidUtf8`.
         let utf8_err = String::from_utf8(vec![0xff, 0xfe]).unwrap_err();
         let err: InitError = utf8_err.into();
         let msg = format!("{err}");

{dirsql-0.3.71 → dirsql-0.3.72}/packages/rust/src/cli/mod.rs

@@ -39,10 +39,6 @@ pub mod server;
 
 pub use server::{serve, serve_with_state};
 
-// ---------------------------------------------------------------------------
-// Public types
-// ---------------------------------------------------------------------------
-
 /// A server-wide `pre-query` command hook, carrying the command template plus
 /// the directory it runs in (the config file's parent). When set on a
 /// [`ServerConfig`], the server passes each `POST /query` request body to the
@@ -57,7 +53,7 @@ pub struct PreQuery {
     pub config_dir: PathBuf,
     /// Per-run timeout. Defaults to the shared 30-second
     /// [`DEFAULT_COMMAND_TIMEOUT`]; override it via [`Self::with_timeout`]
-    /// (the CLI wires the global `[dirsql].hook-timeout` here, #351).
+    /// (the CLI wires the global `[dirsql].hook-timeout` here).
     pub timeout: Duration,
 }
 
@@ -95,7 +91,7 @@ pub struct PostQuery {
     pub config_dir: PathBuf,
     /// Per-run timeout. Defaults to the shared 30-second
     /// [`DEFAULT_COMMAND_TIMEOUT`]; override it via [`Self::with_timeout`]
-    /// (the CLI wires the global `[dirsql].hook-timeout` here, #351).
+    /// (the CLI wires the global `[dirsql].hook-timeout` here).
     pub timeout: Duration,
 }
 
@@ -202,10 +198,8 @@ impl From<DirSQL> for AppState {
     }
 }
 
-/// Symmetric construction for the degraded arm. Lets call sites build the
-/// degraded state with the same `.into()` ergonomics as the ready arm
-/// instead of typing the variant name. The string is the diagnostic that
-/// `/query` and `/events` echo back as a 503 body.
+/// The string is the diagnostic that `/query` and `/events` echo back as a
+/// 503 body.
 impl From<String> for AppState {
     fn from(reason: String) -> Self {
         Self::Unavailable(reason)
@@ -266,14 +260,9 @@ pub enum ServerError {
 mod tests {
     use super::*;
 
-    // `From<DirSQL> for AppState` produces the `Ready` arm -- this is
-    // verified at the integration tier by `from_dirsql_yields_ready_state`
-    // in `tests/cli_integration.rs`, which builds a real `DirSQL` over a
-    // temp directory (so the initial scan runs) and asserts the public
-    // `AppState::Ready` variant. It lived here once but needed
-    // `std::fs::write` to populate the scanned directory, which the
-    // `testing-conventions` `unit lint` isolation rule forbids in a unit
-    // test (effectful std). The pure config-default test below stays inline.
+    // `From<DirSQL> for AppState` needs a real scanned directory, so its
+    // `Ready`-arm test lives in `tests/cli_integration.rs` (unit-lint
+    // isolation forbids the fs setup here).
 
     #[test]
     fn default_config_binds_localhost_7117_with_30s_timeout() {
@@ -287,8 +276,6 @@ mod tests {
 
     #[test]
     fn pre_query_constructor_carries_command_and_dir() {
-        // `PreQuery::new` is pure data plumbing: the command template and the
-        // working directory it will run in, with the shared default timeout.
         let pq = PreQuery::new("to_sql.py {args}", "/proj");
         assert_eq!(pq.command, "to_sql.py {args}");
         assert_eq!(pq.config_dir, PathBuf::from("/proj"));
@@ -311,8 +298,6 @@ mod tests {
 
     #[test]
     fn post_query_constructor_carries_command_and_dir() {
-        // `PostQuery::new` is pure data plumbing: the command template and the
-        // working directory it will run in, with the shared default timeout.
         let pq = PostQuery::new("jq '{results: .}'", "/proj");
         assert_eq!(pq.command, "jq '{results: .}'");
         assert_eq!(pq.config_dir, PathBuf::from("/proj"));
@@ -336,8 +321,6 @@ mod tests {
 
     #[test]
     fn with_query_timeout_overrides_the_default() {
-        // The builder replaces the 30s default with the supplied timeout and
-        // leaves the rest of the config untouched.
         let cfg = ServerConfig::bind("127.0.0.1", 8080).with_query_timeout(Duration::from_secs(5));
         assert_eq!(cfg.query_timeout, Duration::from_secs(5));
         assert_eq!(cfg.host, "127.0.0.1");
@@ -346,9 +329,7 @@ mod tests {
 
     #[test]
     fn app_state_from_string_builds_the_unavailable_arm() {
-        // `String -> AppState` yields the degraded arm carrying the diagnostic
-        // verbatim (the `/query`/`/events` 503 body). `AppState` isn't `Debug`,
-        // so match rather than assert on a rendering.
+        // `AppState` isn't `Debug`, so match instead of asserting on a rendering.
         let state: AppState = "config failed to load".to_string().into();
         match state {
             AppState::Unavailable(reason) => assert_eq!(reason, "config failed to load"),

{dirsql-0.3.71 → dirsql-0.3.72}/packages/rust/src/cli/serialize.rs

@@ -30,8 +30,7 @@ fn cell_to_json(value: &CellValue) -> Value {
     }
 }
 
-/// Hex-encode a byte slice. Used for `BLOB` SQLite values in JSON
-/// output. Lightweight; pulls in no dep just to emit hex.
+/// Hex-encode a byte slice, for `BLOB` SQLite values in JSON output.
 fn hex_encode(bytes: &[u8]) -> String {
     let mut out = String::with_capacity(bytes.len() * 2);
     for b in bytes {
@@ -93,10 +92,6 @@ fn event_to_value(event: &RowEvent) -> Value {
     }
 }
 
-// ---------------------------------------------------------------------------
-// Unit tests
-// ---------------------------------------------------------------------------
-
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -130,7 +125,6 @@ mod tests {
             Some("posts/a.json"),
         );
         assert!(parsed.get("old_row").unwrap().is_null());
-        // event_to_json is the string form of the value it builds.
         assert_eq!(event_to_json(&event), parsed.to_string());
     }
 
@@ -202,8 +196,6 @@ mod tests {
 
     #[test]
     fn blob_cell_becomes_hex_string() {
-        // The Blob arm of `cell_to_json` hex-encodes the bytes into a JSON
-        // string (BLOB columns aren't representable as JSON literals).
         let json = cell_to_json(&CellValue::Blob(vec![0xde, 0xad, 0xbe, 0xef]));
         assert_eq!(json.as_str(), Some("deadbeef"));
     }

{dirsql-0.3.71 → dirsql-0.3.72}/packages/rust/src/cli/server.rs

@@ -96,9 +96,8 @@ fn start_watch_task(db: DirSQL, tx: broadcast::Sender<String>) {
 mod tests {
     use super::*;
 
-    // Binding with an `Unavailable` state needs no DB/filesystem, so this
-    // exercises the real bind / local-addr / graceful-shutdown plumbing
-    // without standing up a full index. Port 0 lets the OS pick a free port.
+    // An `Unavailable` state needs no DB/filesystem, so the real bind /
+    // graceful-shutdown plumbing runs without standing up an index.
     #[tokio::test]
     async fn serve_with_state_binds_an_ephemeral_port_then_shuts_down() {
         let config = ServerConfig::bind("127.0.0.1".to_string(), 0);
@@ -115,10 +114,6 @@ mod tests {
         handle.shutdown().await.expect("graceful shutdown");
     }
 
-    // A `Ready` state drives the `serve` convenience wrapper plus
-    // `start_watch_task` (which attaches `DirSQL::watch` and pumps its stream
-    // into the broadcast channel). Built over an empty temp dir so the scan
-    // touches nothing; the port-0 bind and graceful shutdown are real.
     #[tokio::test]
     async fn serve_with_a_ready_db_attaches_the_watcher_then_shuts_down() {
         let dir = tempfile::tempdir().unwrap();