dirsql 0.4.14__tar.gz → 0.4.15__tar.gz

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

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

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

@@ -1,7 +1,8 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.14
+Version: 0.4.15
 Requires-Dist: tomli>=2 ; python_full_version < '3.11'
+Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index
 Author: Kevin Scott

dirsql-0.4.15/dirsql/cli/main.py

@@ -0,0 +1,66 @@
+"""Console-script entry point. Runs the CLI in-process through the compiled
+extension module — the same `_dirsql` the SDK imports — so the wheel ships one
+copy of the core instead of a `.so` plus a bundled binary (#738).
+
+All argv is forwarded transparently to the core, which owns subcommand
+dispatch; the launcher only prepends what the core cannot work out for itself
+(plugin config fragments, resolved extension paths).
+"""
+
+from __future__ import annotations
+
+import signal
+import sys
+
+from bin_shim import main as run_in_process
+
+from .discover_plugins.with_discovered_plugins import with_discovered_plugins
+from .resolve_config_extensions import with_resolved_extensions
+
+
+def _absorb_interrupt(*_args: object) -> None:
+    """Let the core's own shutdown decide the exit code on SIGINT.
+
+    signal-hook (which tokio uses) *chains*: it runs tokio's handler — which
+    drives `dirsql server`'s graceful shutdown, after which `run_cli` returns
+    0 — and then whatever handler was installed before it. CPython's default
+    is `default_int_handler`, which raises `KeyboardInterrupt`; that lands
+    after `run_cli` has already returned 0 and turns a clean shutdown into a
+    130. This handler occupies that slot without raising, so the core's exit
+    code is the one that survives, exactly as it does when the CLI is its own
+    process.
+
+    A signal arriving when the core is NOT handling signals still terminates:
+    `run_cli` is only reached with this installed, and it returns promptly for
+    every non-server command.
+    """
+
+
+def with_core_owned_signals(handler=signal.signal):
+    """Install `_absorb_interrupt` for SIGINT and return the prior handler."""
+    return handler(signal.SIGINT, _absorb_interrupt)
+
+
+def main(argv: list[str] | None = None) -> int:
+    if argv is None:
+        argv = sys.argv[1:]
+
+    # Discover installed plugins (CLI only) and inject their config fragments as
+    # `-c` flags before resolving extensions; then resolve any package-name
+    # extensions in a TOML config here (the core can't) as `--extension`
+    # flags. Both are no-ops when nothing applies.
+    try:
+        argv = with_discovered_plugins(argv)
+        argv = with_resolved_extensions(argv)
+    except Exception as exc:
+        print(f"dirsql: {exc}", file=sys.stderr)
+        return 1
+
+    previous = with_core_owned_signals()
+    try:
+        return run_in_process(argv=argv, module="dirsql._dirsql")
+    except Exception as exc:
+        print(f"dirsql: {exc}", file=sys.stderr)
+        return 1
+    finally:
+        signal.signal(signal.SIGINT, previous)

{dirsql-0.4.14 → dirsql-0.4.15}/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.14"
+version = "0.4.15"
 # 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
@@ -22,7 +22,10 @@ name = "dirsql_py_ext"
 crate-type = ["cdylib", "rlib"]
 
 [dependencies]
-dirsql.workspace = true
+# `cli` is on so the extension module carries `dirsql::cli::run_cli`: the
+# console script calls it in-process instead of exec'ing a bundled binary
+# (#738), which is what lets `dirsql/_binary/` leave the wheel.
+dirsql = { workspace = true, features = ["cli"] }
 pyo3 = { version = "0.28", features = ["extension-module", "generate-import-lib", "abi3-py310"], optional = true }
 
 [lints.rust]

dirsql-0.4.15/packages/python/changelog.d/2026-08-04-cli-in-process.md

@@ -0,0 +1,3 @@
+**Changed** — the `dirsql` console script now runs **in-process** through the compiled extension module instead of `exec`ing a bundled binary. `_dirsql` is built with the core's `cli` feature and exports `run_cli`, which the launcher calls via [bin-shim](https://pypi.org/project/bin-shim/). Plugin discovery and config-extension resolution are unchanged and still run first. The Windows/POSIX split is gone — `os.execv` on POSIX and `subprocess.run` on Windows are replaced by one in-process call on every platform, so the two no longer drift.
+
+**Removed** — **BREAKING (packaging)**: the wheel no longer ships `dirsql/_binary/`. It held a standalone `dirsql` executable duplicating the core already present in the extension module; `pyproject.toml`'s `[tool.maturin].include` row and the release pipeline's pypi `bundle_cli` staging are both gone. `pip install dirsql && dirsql ...` and `uvx dirsql` behave exactly as before — verified across `--version`, a query, a SQL error (1), an unknown flag (2), and `dirsql server` + Ctrl-C (graceful shutdown, **0**). Anyone locating that binary by path must instead call `dirsql._dirsql.run_cli(argv)`, or install the Rust binary with `cargo install dirsql --features cli`. See [MIGRATIONS.md](../../MIGRATIONS.md). #738.

dirsql-0.4.15/packages/python/e2e-attestations/claude-737-cli-run-shim.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1785873153,
+  "exit_code": 0,
+  "commit": "c5f2a08d38a02c59dde741cddad42720e7efc003",
+  "branch": "claude/737-cli-run-shim"
+}

dirsql-0.4.15/packages/python/e2e-attestations/claude-738-pypi-in-process.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1785876908,
+  "exit_code": 0,
+  "commit": "ed7317d77304d37024796dfe1622cb33b1d4cae7",
+  "branch": "claude/738-pypi-in-process"
+}

dirsql-0.4.15/packages/python/e2e-attestations/claude-739-npm-in-process.json

@@ -0,0 +1,7 @@
+{
+  "command": "uv run python -m pytest tests/e2e/ -x -q",
+  "ran_at": 1785875579,
+  "exit_code": 0,
+  "commit": "7094ce9be3c13c0764176484e62b0aaa5a2d9c1d",
+  "branch": "claude/739-npm-in-process"
+}

dirsql-0.4.15/packages/python/migrations.d/2026-08-04-cli-in-process.md

@@ -0,0 +1,63 @@
+# The wheel's CLI runs in-process; `dirsql/_binary/` is gone
+
+## Summary
+
+The `dirsql` console script no longer `exec`s a bundled binary. The extension
+module (`dirsql._dirsql`) is built with the core's `cli` feature and exports
+`run_cli`; the launcher calls it in this process via bin-shim. The wheel
+therefore ships one copy of the core — the extension module — instead of that
+module *plus* a standalone executable.
+
+## Required changes
+
+**For nearly everyone: none.** `pip install dirsql`, `uvx dirsql`, and the
+`dirsql` console script behave as before: same argv handling, same output,
+same exit codes.
+
+Action is needed only if you located the bundled binary by path — e.g.
+`importlib.resources.files("dirsql") / "_binary" / "dirsql"` — and executed it
+yourself:
+
+- Call `dirsql._dirsql.run_cli(argv)` instead. It returns an exit code rather
+  than terminating the process (`argv` excludes the program name).
+- If you need a standalone executable, `cargo install dirsql --features cli`
+  builds the same code.
+
+## Deprecations removed
+
+`dirsql/_binary/` is no longer part of the wheel. The
+`{ path = "dirsql/_binary/*", format = "wheel" }` maturin include row and the
+pypi `[package.bundle_cli]` release block are both removed.
+
+`dirsql.cli.binary_path` and `dirsql.cli.is_windows` are deleted — both existed
+only to locate and exec that binary.
+
+## Behavior changes without code changes
+
+- **The CLI shares the console script's process.** For `dirsql server` the
+  Python interpreter stays resident for the server's lifetime rather than
+  being replaced by `os.execv`.
+- **Windows and POSIX take the same path.** The `is_windows()` branch
+  (`subprocess.run` vs `os.execv`) is gone, so the platforms cannot drift.
+- **`dirsql server` + Ctrl-C still exits 0.** This needed care and is worth
+  recording. signal-hook (which tokio uses) chains to the handler installed
+  before it; CPython's `default_int_handler` raises `KeyboardInterrupt`, which
+  lands *after* `run_cli` has already returned 0 from its graceful shutdown
+  and which bin-shim then converts to 130. Measured: the naive wiring exits
+  **130** where the old `execv` path exits **0**. The launcher therefore
+  installs a non-raising SIGINT handler for the duration of the run so the
+  core's own exit code survives, and restores the previous handler afterward.
+  This keeps the wheel's behavior identical to before *and* matches the npm
+  launcher (#739), which also exits 0.
+
+## Verification
+
+```
+$ dirsql --version                              # 0   dirsql 0.2.7
+$ dirsql query "SELECT COUNT(*) AS n FROM './'" # 0   [{"n":2}]
+$ dirsql query "SELECT frobnicate()"            # 1   SQLite error: no such function
+$ dirsql --nope                                 # 2   error: unexpected argument
+$ dirsql server --port 7242 & kill -INT $!      # 0   graceful shutdown
+```
+
+Python e2e suite: 27 passed. Unit suite: 108 passed at 100% coverage.

{dirsql-0.4.14 → dirsql-0.4.15}/packages/python/src/lib.rs

@@ -446,6 +446,26 @@ mod python {
         }
     }
 
+    /// Run the `dirsql` CLI in this process and return its exit code.
+    ///
+    /// The console script calls this instead of exec'ing a bundled binary, so
+    /// the wheel ships one copy of the core rather than two (#738). `argv`
+    /// excludes the program name; the core prepends it for clap.
+    ///
+    /// Returns rather than exiting — the caller (bin-shim) owns the process
+    /// exit. Codes are ordinary status codes, never 130/143 (#737).
+    ///
+    /// The GIL is released for the duration: the CLI can run a long-lived
+    /// server, and holding the GIL would wedge every other Python thread in
+    /// the host for its lifetime.
+    #[pyfunction]
+    fn run_cli(py: Python<'_>, argv: Vec<String>) -> i32 {
+        let mut full = Vec::with_capacity(argv.len() + 1);
+        full.push("dirsql".to_string());
+        full.extend(argv);
+        py.detach(|| dirsql::cli::run_cli(full))
+    }
+
     #[pymodule]
     #[pyo3(name = "_dirsql")]
     fn py_dirsql_module(m: &Bound<'_, PyModule>) -> PyResult<()> {
@@ -454,6 +474,7 @@ mod python {
         m.add_class::<PyDirSQL>()?;
         m.add_class::<PyRowEvent>()?;
         m.add_class::<PyScanFailure>()?;
+        m.add_function(wrap_pyfunction!(run_cli, m)?)?;
         Ok(())
     }
 

dirsql-0.4.15/packages/rust/changelog.d/2026-08-04-cli-run-shim.md

@@ -0,0 +1,3 @@
+**Added** — `dirsql::cli::run_cli(argv) -> i32`, the CLI's single entry point, now public on the crate (behind `--features cli`). It parses an explicit `argv`, dispatches the same commands the binary always has, and **returns** its exit code rather than terminating the process: clap's `parse()` calls `std::process::exit` on `--help`, `--version` and usage errors, so `run_cli` parses fallibly and renders the result itself — same text, same streams, same codes, minus the exit. That makes the CLI callable from an embedding host (the pip/npm launchers, via their bindings) instead of only from a process of its own. Exit codes stay ordinary status codes and are never 130/143: a `SIGINT` to `dirsql server` still shuts down gracefully and returns 0, exactly as before.
+
+**Changed** — the 956-line `src/bin/dirsql.rs` (argument parsing, command dispatch, config/state loading) moved into `src/cli/run.rs`; the binary is now a shim that calls `run_cli` and exits with what it returns, so `cargo install dirsql --features cli` and every other entry path run the same code. Behavior is unchanged and was verified so: a capture harness recorded stdout, stderr and exit code for 23 invocations — every clap help/version/usage-error path, each subcommand, and the config/SQL/extension error paths — against binaries built before and after the move, and the two captures are byte-identical.

dirsql-0.4.15/packages/rust/src/bin/dirsql.rs

@@ -0,0 +1,46 @@
+//! The `dirsql` binary: a shim over [`dirsql::cli::run_cli`].
+//!
+//! Every packaging path runs the same code — `cargo install dirsql --features
+//! cli` compiles this shim, and the pip/npm launchers reach `run_cli` through
+//! their bindings. All argument parsing, dispatch and exit-code selection live
+//! in the library so none of it can drift per entry point.
+//!
+//! Only compiled with `--features cli`.
+
+use std::process::ExitCode;
+
+fn main() -> ExitCode {
+    // `run_cli` returns rather than exiting, so the process exit lives here.
+    ExitCode::from(exit_status(dirsql::cli::run_cli(
+        std::env::args().collect(),
+    )))
+}
+
+/// Narrow `run_cli`'s `i32` to the `u8` a process exit status actually
+/// carries. `run_cli` is `i32` for the binding boundary but only ever yields
+/// 0..=255; anything outside that range would be truncated by the OS anyway,
+/// so it is clamped to a generic failure rather than wrapped into a
+/// misleading code (a hypothetical 256 must not surface as success).
+fn exit_status(code: i32) -> u8 {
+    u8::try_from(code).unwrap_or(1)
+}
+
+#[cfg(test)]
+mod tests {
+    use super::exit_status;
+
+    #[test]
+    fn passes_through_the_codes_run_cli_produces() {
+        assert_eq!(exit_status(0), 0);
+        assert_eq!(exit_status(1), 1);
+        assert_eq!(exit_status(2), 2);
+        assert_eq!(exit_status(255), 255);
+    }
+
+    #[test]
+    fn clamps_out_of_range_codes_to_failure() {
+        // Truncating would turn these into 0 — a failure reported as success.
+        assert_eq!(exit_status(256), 1);
+        assert_eq!(exit_status(-1), 1);
+    }
+}

{dirsql-0.4.14 → dirsql-0.4.15}/packages/rust/src/cli/mod.rs

@@ -34,9 +34,11 @@ use crate::command::DEFAULT_COMMAND_TIMEOUT;
 pub mod execute;
 pub mod init;
 pub mod router;
+pub mod run;
 pub mod serialize;
 pub mod server;
 
+pub use run::run_cli;
 pub use server::{serve, serve_with_state};
 
 /// Re-export of the crate-level baked-in default config

dirsql-0.4.14/packages/rust/src/bin/dirsql.rs → dirsql-0.4.15/packages/rust/src/cli/run.rs

@@ -1,4 +1,5 @@
-//! `dirsql` CLI binary. Query is the default; the server is a subcommand:
+//! The `dirsql` CLI: argument parsing and command dispatch behind
+//! [`run_cli`]. Query is the default; the server is a subcommand:
 //! - No subcommand + SQL (`dirsql "<sql>"`): one-shot query, the default
 //!   behavior. Identical to `dirsql query "<sql>"`.
 //! - `query`: explicit synonym for the default one-shot query; see
@@ -8,16 +9,18 @@
 //! - No subcommand and no SQL: a usage error pointing at `dirsql server`.
 //!
 //! Only compiled with `--features cli`.
+//!
+//! The `dirsql` binary is a shim over [`run_cli`], so `cargo install dirsql
+//! --features cli` and every other entry path run the same code.
 
 use std::path::PathBuf;
-use std::process::ExitCode;
 
-use clap::{Args, Parser, Subcommand};
-use dirsql::cli::{
+use super::{
     AppState, PostQuery, PreQuery, ServerConfig, execute::execute_query, init::InitOptions,
     serve_with_state,
 };
-use dirsql::{DirSQL, Extension, Row, Table};
+use crate::{DirSQL, Extension, Row, Table};
+use clap::{Args, Parser, Subcommand};
 
 #[derive(Debug, Parser)]
 #[command(
@@ -126,7 +129,7 @@ impl ConfigArgs {
     /// Apply the index-shaping flags to a builder: `--persist [PATH]` (absent
     /// → no change; bare `--persist` → the default location; `--persist
     /// <path>` → that path) and `--no-ignore`.
-    fn apply_index_flags(&self, mut builder: dirsql::DirSQLBuilder) -> dirsql::DirSQLBuilder {
+    fn apply_index_flags(&self, mut builder: crate::DirSQLBuilder) -> crate::DirSQLBuilder {
         if let Some(path) = &self.persist {
             builder = builder.persist(path.as_ref());
         }
@@ -235,16 +238,51 @@ struct InitArgs {
     force: bool,
 }
 
-#[tokio::main]
-async fn main() -> ExitCode {
-    let mut cli = Cli::parse();
+/// Run the CLI over an explicit `argv` and return its exit code.
+///
+/// The single entry point every packaging path shares: the `dirsql` binary is
+/// a shim over this, and the language launchers reach it through their
+/// bindings. Per the bin-shim contract it **always returns** — it never
+/// terminates the host process, so an embedder stays in control of its own
+/// exit. `argv[0]` is the program name, as `std::env::args()` yields it.
+///
+/// Exit codes are ordinary status codes only (never 130/143): a `SIGINT` to
+/// `dirsql server` shuts down gracefully and returns 0, which is what the
+/// binary has always done. Signals are handled *within* the run by
+/// [`wait_for_shutdown`]; nothing is re-raised on the way out.
+///
+/// Clap's own `parse()` exits the process on `--help`, `--version` and usage
+/// errors, so this parses fallibly and renders the result itself — same text,
+/// same streams, same codes, minus the exit.
+pub fn run_cli(argv: Vec<String>) -> i32 {
+    let mut cli = match Cli::try_parse_from(argv) {
+        Ok(cli) => cli,
+        Err(err) => {
+            let code = err.exit_code();
+            // Writes help/version to stdout and usage errors to stderr,
+            // exactly as clap's own `parse()` does before exiting.
+            let _ = err.print();
+            return code;
+        }
+    };
+
+    let runtime = match tokio::runtime::Runtime::new() {
+        Ok(runtime) => runtime,
+        Err(err) => {
+            eprintln!("dirsql: failed to start the async runtime: {err}");
+            return 1;
+        }
+    };
 
-    match cli.command.take() {
-        Some(Command::Init(args)) => run_init(args),
-        Some(Command::Query(args)) => run_query(args).await,
-        Some(Command::Server(args)) => run_server(args).await,
-        None => run_default(cli).await,
-    }
+    let code = runtime.block_on(async {
+        match cli.command.take() {
+            Some(Command::Init(args)) => run_init(args),
+            Some(Command::Query(args)) => run_query(args).await,
+            Some(Command::Server(args)) => run_server(args).await,
+            None => run_default(cli).await,
+        }
+    });
+    i32::from(code)
 }
 
 /// The default (no-subcommand) behavior: run the positional SQL as a one-shot
@@ -252,7 +290,7 @@ async fn main() -> ExitCode {
 /// to run and no mode selected, so print a usage error pointing at
 /// `dirsql server` — silently starting the server here would re-invert the
 /// default this design deliberately fixed (#662).
-async fn run_default(cli: Cli) -> ExitCode {
+async fn run_default(cli: Cli) -> u8 {
     match cli.sql {
         Some(sql) => {
             run_query(QueryArgs {
@@ -267,7 +305,7 @@ async fn run_default(cli: Cli) -> ExitCode {
                 "dirsql: no query given. Run a query with `dirsql \"SELECT * FROM './'\"`, \
                  or start the HTTP server with `dirsql server`. See `dirsql --help`."
             );
-            ExitCode::from(2)
+            2
         }
     }
 }
@@ -275,15 +313,15 @@ async fn run_default(cli: Cli) -> ExitCode {
 /// One-shot `dirsql query`: build the index exactly as server mode would
 /// (same `load_state` / hook loading), run the SQL through the shared
 /// [`execute_query`] pipeline, print the result JSON on stdout, and exit.
-/// Any [`QueryFailure`](dirsql::cli::execute::QueryFailure) prints its
+/// Any [`QueryFailure`](super::execute::QueryFailure) prints its
 /// message — the same string the HTTP `{"error": …}` body carries — to
 /// stderr with a non-zero exit.
-async fn run_query(args: QueryArgs) -> ExitCode {
+async fn run_query(args: QueryArgs) -> u8 {
     let parser = match resolve_on_file(&args.on_file) {
         Ok(parser) => parser,
         Err(message) => {
             eprintln!("dirsql query: {message}");
-            return ExitCode::from(1);
+            return 1;
         }
     };
     let state = load_state(&args.common, parser);
@@ -308,15 +346,11 @@ async fn run_query(args: QueryArgs) -> ExitCode {
             // failure -- but the index behind them is missing files, and a
             // caller piping into `jq` under `set -e` has no other way to find
             // that out.
-            if skipped {
-                ExitCode::from(PARTIAL_SCAN_EXIT)
-            } else {
-                ExitCode::SUCCESS
-            }
+            if skipped { PARTIAL_SCAN_EXIT } else { 0 }
         }
         Err(failure) => {
             eprintln!("dirsql query: {}", failure.message());
-            ExitCode::from(1)
+            1
         }
     }
 }
@@ -360,14 +394,14 @@ fn query_body(sql: &str) -> String {
     serde_json::json!({ "sql": sql }).to_string()
 }
 
-fn run_init(args: InitArgs) -> ExitCode {
+fn run_init(args: InitArgs) -> u8 {
     let root = match args.root {
         Some(p) => p,
         None => match std::env::current_dir() {
             Ok(p) => p,
             Err(err) => {
                 eprintln!("dirsql init: failed to read current directory: {err}");
-                return ExitCode::from(1);
+                return 1;
             }
         },
     };
@@ -378,16 +412,16 @@ fn run_init(args: InitArgs) -> ExitCode {
         force: args.force,
     };
 
-    match dirsql::cli::init::run(opts) {
-        Ok(()) => ExitCode::SUCCESS,
+    match super::init::run(opts) {
+        Ok(()) => 0,
         Err(err) => {
             eprintln!("dirsql init: {err}");
-            ExitCode::from(1)
+            1
         }
     }
 }
 
-async fn run_server(args: ServerArgs) -> ExitCode {
+async fn run_server(args: ServerArgs) -> u8 {
     // The server has no `--on-file`: clap rejects it as an unknown flag before
     // reaching here. Path-tables served over HTTP keep their stat columns.
     let state = load_state(&args.common, None);
@@ -404,7 +438,7 @@ async fn run_server(args: ServerArgs) -> ExitCode {
         Ok(handle) => handle,
         Err(err) => {
             eprintln!("dirsql: failed to bind: {err}");
-            return ExitCode::from(1);
+            return 1;
         }
     };
 
@@ -417,9 +451,9 @@ async fn run_server(args: ServerArgs) -> ExitCode {
 
     if let Err(err) = handle.shutdown().await {
         eprintln!("dirsql: shutdown error: {err}");
-        return ExitCode::from(1);
+        return 1;
     }
-    ExitCode::SUCCESS
+    0
 }
 
 fn load_state(cfg: &ConfigArgs, path_table_parser: Option<String>) -> AppState {
@@ -517,7 +551,7 @@ fn load_pre_queries(cfg: &ConfigArgs) -> Vec<PreQuery> {
         let Ok(resolved) = config_path.canonicalize() else {
             continue;
         };
-        let Ok(config) = dirsql::config::load_config(&resolved) else {
+        let Ok(config) = crate::config::load_config(&resolved) else {
             continue;
         };
         let Some(command) = config.pre_query else {
@@ -548,7 +582,7 @@ fn load_post_queries(cfg: &ConfigArgs) -> Vec<PostQuery> {
         let Ok(resolved) = config_path.canonicalize() else {
             continue;
         };
-        let Ok(config) = dirsql::config::load_config(&resolved) else {
+        let Ok(config) = crate::config::load_config(&resolved) else {
             continue;
         };
         let Some(command) = config.post_query else {
@@ -580,16 +614,20 @@ 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));
-    }
+    //
+    // Applied unconditionally: `extensions([])` assigns the builder's own
+    // default, and `apply_index_flags` never touches the field, so an
+    // `is_empty()` guard would only add a branch no unit test can reach --
+    // `load_configless_state` needs a real cwd and index (#233).
+    let mut builder = cfg
+        .apply_index_flags(DirSQL::builder().root(root))
+        .extensions(parse_extension_specs(&cfg.extension));
     if let Some(command) = path_table_parser {
         builder = builder.path_table_parser(command);
     }
@@ -599,12 +637,12 @@ fn load_configless_state(cfg: &ConfigArgs, path_table_parser: Option<String>) ->
     }
 }
 
-/// The shipped starter `records` table, parsed from the [`dirsql::DEFAULT_CONFIG_TOML`]
+/// The shipped starter `records` table, parsed from the [`crate::DEFAULT_CONFIG_TOML`]
 /// asset `dirsql init` writes. Used only by the explicit `--include-default`
 /// compose path (#604), which seeds it as a programmatic table *before* the
 /// `-c` configs. There is no implicit no-`-c` fallback (#636).
 fn default_records_table() -> Table {
-    let config = dirsql::config::load_config_str(dirsql::DEFAULT_CONFIG_TOML)
+    let config = crate::config::load_config_str(crate::DEFAULT_CONFIG_TOML)
         .expect("DEFAULT_CONFIG_TOML must be valid dirsql config TOML");
     let table_config = &config.tables[0];
     Table::new(
@@ -987,4 +1025,54 @@ mod tests {
         assert_eq!(exts[0].path, PathBuf::from("/a.so"));
         assert_eq!(exts[0].entrypoint.as_deref(), Some("init::extra"));
     }
+
+    #[test]
+    fn run_cli_returns_zero_for_version_instead_of_exiting() {
+        // The contract this slice exists to establish: clap's own `parse()`
+        // calls `std::process::exit`, which would take an embedding host down
+        // with it. If someone reinstates it, this test kills the test runner
+        // rather than failing politely -- which is the point.
+        assert_eq!(run_cli(vec!["dirsql".into(), "--version".into()]), 0);
+    }
+
+    #[test]
+    fn run_cli_returns_zero_for_help() {
+        assert_eq!(run_cli(vec!["dirsql".into(), "--help".into()]), 0);
+    }
+
+    #[test]
+    fn run_cli_returns_clap_usage_code_for_an_unknown_flag() {
+        assert_eq!(run_cli(vec!["dirsql".into(), "--nope".into()]), 2);
+    }
+
+    #[test]
+    fn run_cli_returns_a_usage_code_for_a_config_flag_before_a_subcommand() {
+        // `args_conflicts_with_subcommands` makes misplacement a hard error
+        // rather than a silently dropped flag (#609); it must surface as a
+        // returned code like any other usage error.
+        let code = run_cli(vec![
+            "dirsql".into(),
+            "-c".into(),
+            "cfg.toml".into(),
+            "query".into(),
+            "SELECT 1".into(),
+        ]);
+        assert_eq!(code, 2);
+    }
+
+    #[test]
+    fn report_scan_failures_is_false_when_the_index_is_degraded() {
+        // The `Ready` arm needs a real scanned directory, so it lives in the
+        // integration tier; the degraded arm short-circuits before any I/O.
+        let state = AppState::Unavailable("config failed to load".to_string());
+        assert!(!report_scan_failures(&state));
+    }
+
+    #[test]
+    fn default_records_table_is_built_from_the_shipped_starter_config() {
+        // `--include-default` seeds this table, so a starter config that
+        // stopped parsing would break that flag rather than `dirsql init`.
+        let table = default_records_table();
+        assert!(table.ddl.contains("records"));
+    }
 }

{dirsql-0.4.14 → dirsql-0.4.15}/pyproject.toml

@@ -23,6 +23,9 @@ dependencies = [
     # to the backport it was derived from. Drop this the day the floor reaches
     # 3.11 again.
     'tomli>=2; python_version < "3.11"',
+    # The console script runs the CLI in-process through this (#738); without
+    # it `dirsql.cli.main` cannot import.
+    "bin-shim>=0.1",
 ]
 
 # Dev/test dependencies live in a PEP 735 dependency-group (not a
@@ -66,13 +69,11 @@ exclude = [
 # `python-source = "python"`) once upstream's verifier handles
 # python-source stripping.
 module-name = "dirsql._dirsql"
-# putitoutthere's `[package.bundle_cli]` recipe (see putitoutthere.toml)
-# cross-compiles the `dirsql` bin per target and stages it under
-# `dirsql/_binary/` before `maturin build`, so it ships inside each
-# wheel as package data. The directory is `.gitignore`d; not in
-# source control.
+# No `dirsql/_binary/*` row any more (#738): the wheel ships no standalone
+# binary. The extension module built here carries the CLI (`run_cli`, via
+# the core's `cli` feature) and the console script calls it in-process, so
+# the wheel holds one copy of the core instead of a `.so` plus a binary.
 include = [
-    { path = "dirsql/_binary/*", format = "wheel" },
     { path = "docs/**/*", format = "sdist" },
 ]
 manifest-path = "packages/python/Cargo.toml"