dirsql 0.4.53__tar.gz → 0.4.55__tar.gz

{dirsql-0.4.53 → dirsql-0.4.55}/Cargo.lock

@@ -552,7 +552,7 @@ checksum = "6184e33543162437515c2e2b48714794e37845ec9851711914eec9d308f6ebe8"
 
 [[package]]
 name = "dirsql"
-version = "0.4.53"
+version = "0.4.55"
 dependencies = [
  "assert_cmd",
  "axum",
@@ -599,7 +599,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.53"
+version = "0.4.55"
 dependencies = [
  "dirsql",
  "pyo3",
@@ -2451,6 +2451,7 @@ version = "1.0.149"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "83fc039473c5595ace860d8c4fafa220ff474b3fc6bfdb4293327f1a37e94d86"
 dependencies = [
+ "indexmap",
  "itoa",
  "memchr",
  "serde",

{dirsql-0.4.53 → dirsql-0.4.55}/Cargo.toml

@@ -16,7 +16,9 @@ repository = "https://github.com/thekevinscott/dirsql"
 [workspace.dependencies]
 dirsql = { path = "packages/rust" }
 serde = { version = "1", features = ["derive"] }
-serde_json = "1"
+# `preserve_order`: a serialized row must keep the projection order the SELECT
+# list asked for, which the default BTreeMap-backed object discards.
+serde_json = { version = "1", features = ["preserve_order"] }
 regex = "1"
 thiserror = "2"
 tokio = { version = "1", features = ["rt", "sync"] }

{dirsql-0.4.53 → dirsql-0.4.55}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.53
+Version: 0.4.55
 Requires-Dist: bin-shim>=0.1
 Summary: Ephemeral SQL index over a local directory
 Keywords: sql,filesystem,directory,sqlite,index

{dirsql-0.4.53 → dirsql-0.4.55}/dirsql/cli/main.py

@@ -18,27 +18,21 @@ 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 keep_sigint_fatal(handler=signal.signal):
+    """Give SIGINT its default disposition for the core's run, returning the prior one.
+
+    No Python-level handler can end a run in progress: `run_cli` detaches the
+    GIL for its whole duration, so nothing reaches the eval loop until the
+    core has already finished — CPython's `default_int_handler` included. Only
+    a disposition the kernel acts on by itself works, which is `SIG_DFL`, and
+    it is what the standalone binary runs with.
+
+    `dirsql server` keeps its exit code: signal-hook (which tokio uses)
+    replaces the disposition when the server registers its handlers, and does
+    not re-raise `SIG_DFL` afterwards, so the core's graceful shutdown is the
+    only thing that acts and its 0 survives.
     """
-
-
-def with_core_owned_signals(handler=signal.signal):
-    """Install `_absorb_interrupt` for SIGINT and return the prior handler."""
-    return handler(signal.SIGINT, _absorb_interrupt)
+    return handler(signal.SIGINT, signal.SIG_DFL)
 
 
 def main(argv: list[str] | None = None) -> int:
@@ -56,7 +50,7 @@ def main(argv: list[str] | None = None) -> int:
         print(f"dirsql: {exc}", file=sys.stderr)
         return 1
 
-    previous = with_core_owned_signals()
+    previous = keep_sigint_fatal()
     try:
         return run_in_process(argv=argv, module="dirsql._dirsql")
     except Exception as exc:

{dirsql-0.4.53 → dirsql-0.4.55}/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.53"
+version = "0.4.55"
 # 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.55/packages/python/changelog.d/2026-09-20-sigint-ends-a-run-in-progress.md

@@ -0,0 +1 @@
+**Fixed** Ctrl-C now ends a `dirsql` run that is still in progress. The launcher installed an empty SIGINT handler for the whole of the core's run, and because the core detaches the GIL for that call no Python handler can run until the work has already finished — so a signal sent during a long directory scan was swallowed and the process was SIGTERM-only. SIGINT is left at its default disposition instead, which the kernel acts on immediately, matching the standalone binary. `dirsql server`'s graceful shutdown still exits 0.

{dirsql-0.4.53 → dirsql-0.4.55}/packages/python/changelog.d/README.md

@@ -14,4 +14,4 @@ Each PR that touches this package's public-facing source adds one file here:
 Fragments are **permanent and append-only** — nothing is ever assembled back
 into a single `CHANGELOG.md`, and the release↔entry mapping comes from
 `git log --tags`. This README is not a fragment and never satisfies the
-changelog gate. See AGENTS.md, "Changelog and Migrations".
+changelog gate. See `agents/reference/changelog-migrations.md`.

dirsql-0.4.55/packages/python/e2e-attestations/claude-1164-sigint-fatal.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1789910327,
+  "exit_code": 0,
+  "commit": "dfc68b057d52f3d4f586fd0233f292ccc2062dd6",
+  "branch": "claude/1164-sigint-fatal"
+}

dirsql-0.4.55/packages/python/e2e-attestations/claude-1170-projection-order.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1790181270,
+  "exit_code": 0,
+  "commit": "010d9772867fcb1e1b56ce4a77eb8b0223b0870a",
+  "branch": "claude/1170-projection-order"
+}

dirsql-0.4.55/packages/python/migrations.d/2026-09-20-sigint-ends-a-run-in-progress.md

@@ -0,0 +1,35 @@
+### SIGINT ends a run in progress through the Python launcher
+
+**Summary**
+
+The `dirsql` console script installed an empty SIGINT handler for the duration of the core's run. A signal arriving during a long directory scan was therefore discarded, and the process could only be ended with SIGTERM. SIGINT is now left at its default disposition for that window, so the kernel terminates the process immediately. No API changes; the observable difference is that a signal that used to do nothing now ends the process with the usual 128+SIGINT status.
+
+**Required changes**
+
+| Before | After |
+| --- | --- |
+| `kill -INT <pid>` during a query: ignored; the run continues to completion | `kill -INT <pid>` during a query: the process dies of SIGINT (shell reports `130`) |
+| Ctrl-C while the REPL is executing a statement: ignored | Ctrl-C while the REPL is executing a statement: the session ends |
+
+A script that sent SIGINT to a `dirsql` process and relied on it being ignored must stop sending it. A script that escalated to SIGTERM after an ignored SIGINT can drop the escalation.
+
+`dirsql server` is unchanged: its graceful shutdown still exits `0` on SIGINT and SIGTERM. Ctrl-C at an idle REPL prompt is unchanged too — reedline reads it as a key event, not a signal.
+
+**Deprecations removed**
+
+_None._
+
+**Behavior changes without code changes**
+
+The exit status of an interrupted run changes from "no exit" to death by SIGINT. This aligns the Python launcher with the standalone `dirsql` binary, which has always behaved this way.
+
+**Verification**
+
+Against a directory large enough to take a few seconds to scan:
+
+```bash
+dirsql "SELECT count(*) FROM './'"   # press Ctrl-C while it runs
+echo $?
+```
+
+Expected: the process ends promptly and the shell reports `130`. Before this change it kept running and the SIGINT was discarded. Run it in the foreground: a non-interactive shell sets SIGINT to `SIG_IGN` for `&` background jobs, which hides the difference.

{dirsql-0.4.53 → dirsql-0.4.55}/packages/python/migrations.d/README.md

@@ -15,5 +15,5 @@ the API adds one file here:
   `_None._` where a subsection does not apply.
 
 Fragments are **permanent and append-only** — nothing is assembled back into a
-single `MIGRATIONS.md`. This README is not a fragment. See AGENTS.md,
-"Changelog and Migrations".
+single `MIGRATIONS.md`. This README is not a fragment. See
+`agents/reference/changelog-migrations.md`.

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

{dirsql-0.4.53 → dirsql-0.4.55}/packages/rust/src/cli/execute.rs

@@ -15,7 +15,7 @@ use serde::Deserialize;
 use serde_json::Value;
 
 use super::AppState;
-use super::serialize::rows_to_json;
+use super::serialize::result_to_json;
 use crate::{DirSQL, DirSqlError};
 
 /// Why a query failed, classified independently of transport. The HTTP
@@ -66,10 +66,14 @@ pub async fn execute_query(
 
     let db = require_ready(state)?;
 
-    let join = run_bounded(timeout, tokio::task::spawn_blocking(move || db.query(&sql))).await?;
+    let join = run_bounded(
+        timeout,
+        tokio::task::spawn_blocking(move || db.query_ordered(&sql)),
+    )
+    .await?;
 
     match join {
-        Ok(Ok(rows)) => Ok(Value::Array(rows_to_json(&rows))),
+        Ok(Ok(result)) => Ok(Value::Array(result_to_json(&result))),
         Ok(Err(err)) => Err(classify_query_error(err)),
         Err(join_err) => Err(QueryFailure::Internal(join_err.to_string())),
     }

{dirsql-0.4.53 → dirsql-0.4.55}/packages/rust/src/cli/serialize.rs

@@ -2,13 +2,29 @@
 
 use serde_json::{Map, Value};
 
-use crate::Row;
 use crate::db::Value as CellValue;
 use crate::differ::RowEvent;
 use crate::row_event_flat::flatten_row_event;
+use crate::{QueryResult, Row};
+
+/// Serialize a query result, each object keyed in projection order. Row events
+/// carry no projection, so they keep going through [`row_to_json`].
+pub(super) fn result_to_json(result: &QueryResult) -> Vec<Value> {
+    result
+        .rows
+        .iter()
+        .map(|row| ordered_row_to_json(&result.columns, row))
+        .collect()
+}
 
-pub(super) fn rows_to_json(rows: &[Row]) -> Vec<Value> {
-    rows.iter().map(row_to_json).collect()
+fn ordered_row_to_json(columns: &[String], row: &Row) -> Value {
+    let mut map = Map::with_capacity(columns.len());
+    for column in columns {
+        if let Some(value) = row.get(column) {
+            map.insert(column.clone(), cell_to_json(value));
+        }
+    }
+    Value::Object(map)
 }
 
 pub(super) fn row_to_json(row: &Row) -> Value {
@@ -75,6 +91,35 @@ mod tests {
         assert_eq!(json.get("count").and_then(Value::as_i64), Some(3));
     }
 
+    #[test]
+    fn a_result_serializes_its_rows_in_projection_order() {
+        let mut row: Row = HashMap::new();
+        row.insert("title".into(), CellValue::Text("Hello".into()));
+        row.insert("count".into(), CellValue::Integer(3));
+        let result = QueryResult {
+            columns: vec!["count".into(), "title".into()],
+            rows: vec![row],
+        };
+
+        let json = result_to_json(&result);
+
+        assert_eq!(json[0].to_string(), r#"{"count":3,"title":"Hello"}"#);
+    }
+
+    #[test]
+    fn a_column_no_row_key_matches_is_left_out() {
+        let mut row: Row = HashMap::new();
+        row.insert("title".into(), CellValue::Text("Hello".into()));
+        let result = QueryResult {
+            columns: vec!["title".into(), "title".into()],
+            rows: vec![row],
+        };
+
+        let json = result_to_json(&result);
+
+        assert_eq!(json[0].to_string(), r#"{"title":"Hello"}"#);
+    }
+
     #[test]
     fn insert_event_emits_expected_shape() {
         let mut row: Row = HashMap::new();

{dirsql-0.4.53 → dirsql-0.4.55}/packages/rust/src/cli/table.rs

@@ -11,7 +11,7 @@
 //! swallowing the table; laying the table out to the terminal's width, and
 //! paging a long result, are both out of scope.
 
-use std::collections::BTreeSet;
+use std::collections::HashSet;
 
 use serde_json::Value;
 
@@ -53,16 +53,22 @@ pub(super) fn render(rows: &[Value]) -> String {
     out
 }
 
-/// Every column any row carries. Rows are JSON objects, so the keys arrive
-/// sorted and stay in step with the JSON rendering of the same result.
+/// Every column any row carries, first seen first. Rows are JSON objects
+/// serialized in projection order, so that is the order the SELECT list asked
+/// for -- and the same order the JSON rendering of this result prints.
 fn columns(rows: &[Value]) -> Vec<String> {
-    let mut names = BTreeSet::new();
+    let mut seen = HashSet::new();
+    let mut names = Vec::new();
     for row in rows {
         if let Value::Object(map) = row {
-            names.extend(map.keys().cloned());
+            for key in map.keys() {
+                if seen.insert(key.clone()) {
+                    names.push(key.clone());
+                }
+            }
         }
     }
-    names.into_iter().collect()
+    names
 }
 
 /// One row's cells, in column order. A row missing a column renders it as
@@ -242,6 +248,25 @@ mod tests {
         }
     }
 
+    #[test]
+    fn the_header_keeps_the_order_the_row_carries() {
+        // Rows arrive serialized in projection order; re-sorting them here is
+        // what made `SELECT size, basename` print `basename  size`.
+        let table = rendered([row([
+            ("size", Value::from(6)),
+            ("basename", Value::from("a.md")),
+        ])]);
+
+        assert!(table.starts_with("size  basename\n"), "{table:?}");
+    }
+
+    #[test]
+    fn a_later_rows_new_columns_come_after_the_earlier_ones() {
+        let table = rendered([row([("b", Value::from(1))]), row([("a", Value::from(2))])]);
+
+        assert!(table.starts_with("b     a\n"), "{table:?}");
+    }
+
     #[test]
     fn every_column_any_row_carries_is_shown() {
         // A ragged result must not silently drop the columns only some rows

{dirsql-0.4.53 → dirsql-0.4.55}/packages/rust/src/db.rs

@@ -244,6 +244,13 @@ pub fn ensure_internal_rows_table(conn: &Connection) -> rusqlite::Result<()> {
     )
 }
 
+/// One query's rows plus the column order the SELECT list asked for.
+#[derive(Debug, Clone, PartialEq)]
+pub struct QueryResult {
+    pub columns: Vec<String>,
+    pub rows: Vec<HashMap<String, Value>>,
+}
+
 pub struct Db {
     conn: Connection,
     /// The directory a path-table's glob is resolved against. `None` disables
@@ -714,6 +721,14 @@ impl Db {
     /// internal writes (`insert_row`, delete-by-file, persist), which never go
     /// through `query()`, are unaffected.
     pub fn query(&self, sql: &str) -> Result<Vec<HashMap<String, Value>>> {
+        self.query_ordered(sql).map(|result| result.rows)
+    }
+
+    /// [`query`](Self::query), plus the projection order. A row is a
+    /// `HashMap`, so the order the SELECT list asked for survives only in
+    /// [`QueryResult::columns`]; a renderer that re-derives its columns from
+    /// row keys prints them alphabetically instead.
+    pub fn query_ordered(&self, sql: &str) -> Result<QueryResult> {
         // Bracket the whole statement, prepare included: a worker-backed
         // function called on every row makes this the slowest thing dirsql
         // does, and the guard is what erases the counter before the caller
@@ -757,7 +772,10 @@ impl Db {
         for row in rows {
             results.push(row?);
         }
-        Ok(results)
+        Ok(QueryResult {
+            columns: column_names,
+            rows: results,
+        })
     }
 
     /// Prepare `sql` with the internal-table / ATTACH authorizer installed for
@@ -1026,6 +1044,40 @@ mod tests {
         assert!(!rows[0].contains_key("_dirsql_row_index"));
     }
 
+    #[test]
+    fn query_ordered_reports_the_select_list_order() {
+        let db = Db::new().unwrap();
+        db.create_table("docs", "CREATE TABLE docs (title TEXT, draft INTEGER)")
+            .unwrap();
+
+        let result = db.query_ordered("SELECT draft, title FROM docs").unwrap();
+
+        assert_eq!(
+            result.columns,
+            vec!["draft".to_string(), "title".to_string()]
+        );
+    }
+
+    #[test]
+    fn query_ordered_carries_the_same_rows_query_returns() {
+        let db = Db::new().unwrap();
+        db.create_table("docs", "CREATE TABLE docs (title TEXT, draft INTEGER)")
+            .unwrap();
+        let row = HashMap::from([
+            ("title".into(), Value::Text("Hello".into())),
+            ("draft".into(), Value::Integer(0)),
+        ]);
+        db.insert_row("docs", &row, "docs/hello.md", 0).unwrap();
+
+        let result = db.query_ordered("SELECT title, draft FROM docs").unwrap();
+
+        assert_eq!(
+            result.rows,
+            db.query("SELECT title, draft FROM docs").unwrap()
+        );
+        assert_eq!(result.rows[0]["title"], Value::Text("Hello".into()));
+    }
+
     #[test]
     fn pragma_table_info_matches_user_ddl_exactly() {
         let db = Db::new().unwrap();

{dirsql-0.4.53 → dirsql-0.4.55}/packages/rust/src/lib.rs

@@ -77,7 +77,7 @@ use std::time::Duration;
 use thiserror::Error;
 
 pub use crate::config::ExtensionSpec as Extension;
-pub use crate::db::{DbError, Value};
+pub use crate::db::{DbError, QueryResult, Value};
 pub use crate::differ::RowEvent;
 #[doc(hidden)]
 pub use crate::row_event_flat::{FlatRowEvent, flatten_row_event};
@@ -404,8 +404,15 @@ impl DirSQL {
     /// keeps the ephemeral index consistent with the on-disk files that back
     /// it: mutations only happen through the watcher/indexer pipeline.
     pub fn query(&self, sql: &str) -> Result<Vec<Row>> {
+        self.query_ordered(sql).map(|result| result.rows)
+    }
+
+    /// [`query`](Self::query), plus the projection order in
+    /// [`QueryResult::columns`]. A [`Row`] is a `HashMap`, so a caller that
+    /// renders columns in the order the user asked for needs this instead.
+    pub fn query_ordered(&self, sql: &str) -> Result<QueryResult> {
         let db = self.inner.db.lock().map_err(DirSqlError::lock)?;
-        db.query(sql).map_err(map_db_error)
+        db.query_ordered(sql).map_err(map_db_error)
     }
 
     /// Lazily create the filesystem watcher. Idempotent; subsequent calls are