dirsql 0.4.6__tar.gz → 0.4.7__tar.gz

{dirsql-0.4.6 → dirsql-0.4.7}/Cargo.lock

@@ -470,6 +470,7 @@ dependencies = [
  "futures-executor",
  "futures-util",
  "globset",
+ "ignore",
  "libc",
  "notify",
  "predicates",
@@ -499,7 +500,7 @@ dependencies = [
 
 [[package]]
 name = "dirsql-py-ext"
-version = "0.4.6"
+version = "0.4.7"
 dependencies = [
  "dirsql",
  "pyo3",
@@ -1138,6 +1139,22 @@ dependencies = [
  "icu_properties",
 ]
 
+[[package]]
+name = "ignore"
+version = "0.4.32"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "0b17771570a2b94107741a7b033f19132c2eee21d59d21b24d2ced26500bd66e"
+dependencies = [
+ "crossbeam-deque",
+ "globset",
+ "log",
+ "memchr",
+ "regex-automata",
+ "same-file",
+ "walkdir",
+ "winapi-util",
+]
+
 [[package]]
 name = "indexmap"
 version = "2.14.0"

{dirsql-0.4.6 → dirsql-0.4.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: dirsql
-Version: 0.4.6
+Version: 0.4.7
 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.6/packages/python → dirsql-0.4.7}/docs/reference/cli.md

@@ -69,6 +69,7 @@ Config flags are subcommand-local: pass them after `server`
 | `--host <addr>` | `localhost` | Bind address. |
 | `--port <n>` | `7117` | TCP port to bind. |
 | `--persist [<path>]` | off | Keep the SQLite index on disk between runs so a restart only re-parses files that actually changed. Bare `--persist` caches at `<root>/.dirsql/cache.db`; `--persist <path>` caches at `<path>`. Off by default (the index is ephemeral). Also available on [`dirsql query`](#dirsql-query). See [Keep the index across restarts](../howto/persist.md). |
+| `--no-ignore` | off | Scan files a `.gitignore` would hide. [Path-tables](./path-tables.md#skip-rules) respect `.gitignore` files by default; this flag restores the full walk. The built-in skips (`node_modules`/`.git`) and configured `ignore` patterns still apply. Also available on [`dirsql query`](#dirsql-query). |
 | `--extension <path>` | none | Load a SQLite extension by literal path, overriding the config's `[[dirsql.extension]]` entries. Repeatable. Format: `<path>` or `<path>::<entrypoint>`. Internal plumbing for the pip/npm launchers, which resolve package-name extensions and pass the resolved paths here — not intended for direct use. When any `--extension` is present, the config file's own extension entries are not loaded. |
 | `--version` | | Print the version and exit. |
 | `--help` | | Print usage and exit. |
@@ -163,6 +164,8 @@ uses**, so behavior is identical to `POST /query` by construction:
   on-disk cache. Because its value is optional, place a bare `--persist` after
   the SQL (`dirsql query "SELECT …" --persist`) or use the `=` form
   (`--persist=/path`) so it does not swallow the SQL argument.
+- **`--no-ignore`** is honored: path-tables in the query scan files a
+  `.gitignore` would hide. See [Skip rules](./path-tables.md#skip-rules).
 - **Hooks** ([`pre-query`](./hooks.md#pre-query) /
   [`post-query`](./hooks.md#post-query)) and the
   [`[dirsql].hook-timeout`](./config.md#dirsql-keys) apply identically.

{dirsql-0.4.6 → dirsql-0.4.7}/docs/reference/path-tables.md

@@ -179,19 +179,48 @@ A path-table scan applies the same [`ignore`](/reference/config) patterns your
 declared tables use, plus two built-in defaults so a zero-config
 `SELECT * FROM './'` does not drown in machinery:
 
-- `node_modules/**`
-- `.git/**`
+- `**/node_modules/**`
+- `**/.git/**`
+
+Both apply at any depth, so a `node_modules` nested inside a subdirectory is
+skipped just like one at the top.
+
+### `.gitignore`
+
+Path-table scans also respect `.gitignore` files by default, the way fd and
+ripgrep do: a `.gitignore` anywhere in the tree applies below its own
+directory, deeper files override shallower ones, `!pattern` re-includes, and
+an ignored directory is pruned rather than walked. In a typical repo this
+excludes build output, virtualenvs, and caches with zero ceremony. No `.git`
+directory is required — a `.gitignore` in any scanned directory counts — and
+the built-in defaults above remain as a floor for directories with no
+`.gitignore` at all.
+
+Pass [`--no-ignore`](./cli.md#flags) to restore the full walk — the
+determinism switch for scripted use, since results otherwise depend on
+`.gitignore` state. It disables only the `.gitignore` respect; the built-in
+defaults and configured `ignore` patterns still apply.
+
+### Naming a skipped directory
 
 Skip rules are judged on the part of the path *below* what you named outright,
-so pointing at a skipped directory still scans it:
+so pointing at a skipped directory — built-in or gitignored — still scans it:
 
 ```sql
 SELECT path FROM './';                     -- no node_modules rows
 SELECT path FROM './node_modules/*/package.json';  -- scans it anyway
+SELECT path FROM './dist';                 -- scans dist/ even when gitignored
 ```
 
-Dotfiles are ordinary files: `'./'` and `'./*'` include them. Add an `ignore`
-pattern if you would rather not see them.
+A `.gitignore` at or below the directory you named still filters beneath it;
+only rules inherited from above it are set aside.
+
+### Hidden files
+
+Dotfiles are ordinary files: `'./'` and `'./*'` include them, with or without
+`--no-ignore`. This is a deliberate divergence from fd/ripgrep — querying
+dotfile directories (`.claude/`, …) is a first-class `dirsql` use case. Add an
+`ignore` pattern if you would rather not see them.
 
 ## Joining against declared tables
 

{dirsql-0.4.6 → dirsql-0.4.7}/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.6"
+version = "0.4.7"
 # 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.6/packages/rust → dirsql-0.4.7/packages/python}/docs/reference/cli.md

@@ -69,6 +69,7 @@ Config flags are subcommand-local: pass them after `server`
 | `--host <addr>` | `localhost` | Bind address. |
 | `--port <n>` | `7117` | TCP port to bind. |
 | `--persist [<path>]` | off | Keep the SQLite index on disk between runs so a restart only re-parses files that actually changed. Bare `--persist` caches at `<root>/.dirsql/cache.db`; `--persist <path>` caches at `<path>`. Off by default (the index is ephemeral). Also available on [`dirsql query`](#dirsql-query). See [Keep the index across restarts](../howto/persist.md). |
+| `--no-ignore` | off | Scan files a `.gitignore` would hide. [Path-tables](./path-tables.md#skip-rules) respect `.gitignore` files by default; this flag restores the full walk. The built-in skips (`node_modules`/`.git`) and configured `ignore` patterns still apply. Also available on [`dirsql query`](#dirsql-query). |
 | `--extension <path>` | none | Load a SQLite extension by literal path, overriding the config's `[[dirsql.extension]]` entries. Repeatable. Format: `<path>` or `<path>::<entrypoint>`. Internal plumbing for the pip/npm launchers, which resolve package-name extensions and pass the resolved paths here — not intended for direct use. When any `--extension` is present, the config file's own extension entries are not loaded. |
 | `--version` | | Print the version and exit. |
 | `--help` | | Print usage and exit. |
@@ -163,6 +164,8 @@ uses**, so behavior is identical to `POST /query` by construction:
   on-disk cache. Because its value is optional, place a bare `--persist` after
   the SQL (`dirsql query "SELECT …" --persist`) or use the `=` form
   (`--persist=/path`) so it does not swallow the SQL argument.
+- **`--no-ignore`** is honored: path-tables in the query scan files a
+  `.gitignore` would hide. See [Skip rules](./path-tables.md#skip-rules).
 - **Hooks** ([`pre-query`](./hooks.md#pre-query) /
   [`post-query`](./hooks.md#post-query)) and the
   [`[dirsql].hook-timeout`](./config.md#dirsql-keys) apply identically.

{dirsql-0.4.6/packages/rust → dirsql-0.4.7/packages/python}/docs/reference/path-tables.md

@@ -179,19 +179,48 @@ A path-table scan applies the same [`ignore`](/reference/config) patterns your
 declared tables use, plus two built-in defaults so a zero-config
 `SELECT * FROM './'` does not drown in machinery:
 
-- `node_modules/**`
-- `.git/**`
+- `**/node_modules/**`
+- `**/.git/**`
+
+Both apply at any depth, so a `node_modules` nested inside a subdirectory is
+skipped just like one at the top.
+
+### `.gitignore`
+
+Path-table scans also respect `.gitignore` files by default, the way fd and
+ripgrep do: a `.gitignore` anywhere in the tree applies below its own
+directory, deeper files override shallower ones, `!pattern` re-includes, and
+an ignored directory is pruned rather than walked. In a typical repo this
+excludes build output, virtualenvs, and caches with zero ceremony. No `.git`
+directory is required — a `.gitignore` in any scanned directory counts — and
+the built-in defaults above remain as a floor for directories with no
+`.gitignore` at all.
+
+Pass [`--no-ignore`](./cli.md#flags) to restore the full walk — the
+determinism switch for scripted use, since results otherwise depend on
+`.gitignore` state. It disables only the `.gitignore` respect; the built-in
+defaults and configured `ignore` patterns still apply.
+
+### Naming a skipped directory
 
 Skip rules are judged on the part of the path *below* what you named outright,
-so pointing at a skipped directory still scans it:
+so pointing at a skipped directory — built-in or gitignored — still scans it:
 
 ```sql
 SELECT path FROM './';                     -- no node_modules rows
 SELECT path FROM './node_modules/*/package.json';  -- scans it anyway
+SELECT path FROM './dist';                 -- scans dist/ even when gitignored
 ```
 
-Dotfiles are ordinary files: `'./'` and `'./*'` include them. Add an `ignore`
-pattern if you would rather not see them.
+A `.gitignore` at or below the directory you named still filters beneath it;
+only rules inherited from above it are set aside.
+
+### Hidden files
+
+Dotfiles are ordinary files: `'./'` and `'./*'` include them, with or without
+`--no-ignore`. This is a deliberate divergence from fd/ripgrep — querying
+dotfile directories (`.claude/`, …) is a first-class `dirsql` use case. Add an
+`ignore` pattern if you would rather not see them.
 
 ## Joining against declared tables
 

dirsql-0.4.7/packages/python/e2e-attestations/feat-742-gitignore-by-default.json

@@ -0,0 +1,7 @@
+{
+  "command": "just test-e2e",
+  "ran_at": 1785774560,
+  "exit_code": 0,
+  "commit": "3559de42c86374f67ceeb7266a6867193234cec1",
+  "branch": "feat/742-gitignore-by-default"
+}

{dirsql-0.4.6 → dirsql-0.4.7}/packages/rust/Cargo.toml

@@ -55,6 +55,9 @@ clap = { version = "4", features = ["derive"], optional = true }
 futures = { version = "0.3", optional = true }
 futures-channel.workspace = true
 globset = "0.4"
+# Hierarchical `.gitignore` matching for path-table scans (the fd/ripgrep
+# semantics), without adopting its walker: the scan keeps `walkdir`.
+ignore = "0.4"
 notify = "7"
 rusqlite = { version = "0.34", features = ["bundled", "load_extension", "hooks", "vtab"] }
 serde.workspace = true

dirsql-0.4.7/packages/rust/changelog.d/2026-08-03-gitignore-by-default.md

@@ -0,0 +1,9 @@
+**Changed** Path-table scans (`SELECT ... FROM './'`) now respect
+`.gitignore` files by default, the way fd/ripgrep do: a `.gitignore` anywhere
+in the tree applies below its own directory (hierarchically, `!pattern`
+re-includes), and ignored directories are pruned rather than walked. No
+`.git` directory is required. Hidden files are still scanned (deliberate
+divergence from fd/rg), the built-in `node_modules`/`.git` defaults remain as
+a floor, and naming a gitignored directory outright (`FROM './dist'`) still
+scans it. The new CLI flag `--no-ignore` and Rust builder option
+`DirSQLBuilder::no_ignore(bool)` restore the full walk. (#742)

dirsql-0.4.7/packages/rust/changelog.d/2026-08-03-nested-default-ignores.md

@@ -0,0 +1,11 @@
+**Fixed**
+
+- **Path-table scans now skip `node_modules` and `.git` at any depth.** The
+  built-in `DEFAULT_IGNORES` were anchored at the table root
+  (`node_modules/**`, `.git/**`), so nested occurrences such as
+  `presentations/foo/node_modules/...` leaked into `SELECT ... FROM './'`
+  results. The defaults are now `**/node_modules/**` and `**/.git/**`, and
+  the directory walker prunes wholly-ignored directories during traversal
+  instead of filtering after the walk, so an ignored tree is never read at
+  all. Naming a skipped directory outright (e.g.
+  `FROM './apps/site/node_modules'`) still scans it, at any depth. (#741)

{dirsql-0.4.6 → dirsql-0.4.7/packages/rust}/docs/reference/cli.md

@@ -69,6 +69,7 @@ Config flags are subcommand-local: pass them after `server`
 | `--host <addr>` | `localhost` | Bind address. |
 | `--port <n>` | `7117` | TCP port to bind. |
 | `--persist [<path>]` | off | Keep the SQLite index on disk between runs so a restart only re-parses files that actually changed. Bare `--persist` caches at `<root>/.dirsql/cache.db`; `--persist <path>` caches at `<path>`. Off by default (the index is ephemeral). Also available on [`dirsql query`](#dirsql-query). See [Keep the index across restarts](../howto/persist.md). |
+| `--no-ignore` | off | Scan files a `.gitignore` would hide. [Path-tables](./path-tables.md#skip-rules) respect `.gitignore` files by default; this flag restores the full walk. The built-in skips (`node_modules`/`.git`) and configured `ignore` patterns still apply. Also available on [`dirsql query`](#dirsql-query). |
 | `--extension <path>` | none | Load a SQLite extension by literal path, overriding the config's `[[dirsql.extension]]` entries. Repeatable. Format: `<path>` or `<path>::<entrypoint>`. Internal plumbing for the pip/npm launchers, which resolve package-name extensions and pass the resolved paths here — not intended for direct use. When any `--extension` is present, the config file's own extension entries are not loaded. |
 | `--version` | | Print the version and exit. |
 | `--help` | | Print usage and exit. |
@@ -163,6 +164,8 @@ uses**, so behavior is identical to `POST /query` by construction:
   on-disk cache. Because its value is optional, place a bare `--persist` after
   the SQL (`dirsql query "SELECT …" --persist`) or use the `=` form
   (`--persist=/path`) so it does not swallow the SQL argument.
+- **`--no-ignore`** is honored: path-tables in the query scan files a
+  `.gitignore` would hide. See [Skip rules](./path-tables.md#skip-rules).
 - **Hooks** ([`pre-query`](./hooks.md#pre-query) /
   [`post-query`](./hooks.md#post-query)) and the
   [`[dirsql].hook-timeout`](./config.md#dirsql-keys) apply identically.

{dirsql-0.4.6/packages/python → dirsql-0.4.7/packages/rust}/docs/reference/path-tables.md

@@ -179,19 +179,48 @@ A path-table scan applies the same [`ignore`](/reference/config) patterns your
 declared tables use, plus two built-in defaults so a zero-config
 `SELECT * FROM './'` does not drown in machinery:
 
-- `node_modules/**`
-- `.git/**`
+- `**/node_modules/**`
+- `**/.git/**`
+
+Both apply at any depth, so a `node_modules` nested inside a subdirectory is
+skipped just like one at the top.
+
+### `.gitignore`
+
+Path-table scans also respect `.gitignore` files by default, the way fd and
+ripgrep do: a `.gitignore` anywhere in the tree applies below its own
+directory, deeper files override shallower ones, `!pattern` re-includes, and
+an ignored directory is pruned rather than walked. In a typical repo this
+excludes build output, virtualenvs, and caches with zero ceremony. No `.git`
+directory is required — a `.gitignore` in any scanned directory counts — and
+the built-in defaults above remain as a floor for directories with no
+`.gitignore` at all.
+
+Pass [`--no-ignore`](./cli.md#flags) to restore the full walk — the
+determinism switch for scripted use, since results otherwise depend on
+`.gitignore` state. It disables only the `.gitignore` respect; the built-in
+defaults and configured `ignore` patterns still apply.
+
+### Naming a skipped directory
 
 Skip rules are judged on the part of the path *below* what you named outright,
-so pointing at a skipped directory still scans it:
+so pointing at a skipped directory — built-in or gitignored — still scans it:
 
 ```sql
 SELECT path FROM './';                     -- no node_modules rows
 SELECT path FROM './node_modules/*/package.json';  -- scans it anyway
+SELECT path FROM './dist';                 -- scans dist/ even when gitignored
 ```
 
-Dotfiles are ordinary files: `'./'` and `'./*'` include them. Add an `ignore`
-pattern if you would rather not see them.
+A `.gitignore` at or below the directory you named still filters beneath it;
+only rules inherited from above it are set aside.
+
+### Hidden files
+
+Dotfiles are ordinary files: `'./'` and `'./*'` include them, with or without
+`--no-ignore`. This is a deliberate divergence from fd/ripgrep — querying
+dotfile directories (`.claude/`, …) is a first-class `dirsql` use case. Add an
+`ignore` pattern if you would rather not see them.
 
 ## Joining against declared tables
 

dirsql-0.4.7/packages/rust/migrations.d/2026-08-03-gitignore-by-default.md

@@ -0,0 +1,52 @@
+### Path-table scans respect `.gitignore` by default
+
+#### Summary
+
+Path-table scans (`SELECT ... FROM './'`, `FROM '/abs/**'`, and the `--on-file`
+parsed form) now respect `.gitignore` files by default — hierarchically, with
+traversal pruning, like fd/ripgrep — in the Rust core and therefore in the CLI
+and every SDK binding. A query over a repository returns fewer rows than
+before when `.gitignore` names files or directories in the scanned tree. No
+API signature changed; the opt-out is the new CLI flag `--no-ignore` and Rust
+builder option `DirSQLBuilder::no_ignore(bool)`. Declared (config) tables are
+unaffected.
+
+#### Required changes
+
+_None required for code._ To keep the previous full-walk behavior for a
+path-table query:
+
+| Surface | Before | After |
+| ------- | ------ | ----- |
+| CLI | `dirsql "SELECT * FROM './'"` (scanned gitignored files) | `dirsql "SELECT * FROM './'" --no-ignore` |
+| Rust SDK | `DirSQL::builder().root(r).build()` (scanned gitignored files) | `DirSQL::builder().root(r).no_ignore(true).build()` |
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- Path-table scans: previously `.gitignore` files were not consulted, so
+  gitignored files (build output, virtualenvs, caches) appeared as rows; now
+  any `.gitignore` in the scanned tree excludes its matches below its own
+  directory and ignored directories are pruned. Row counts over repositories
+  shrink accordingly.
+- Unchanged, for scoping: hidden files are still scanned; the built-in
+  `**/node_modules/**` / `**/.git/**` defaults and configured `ignore`
+  patterns still apply (also under `--no-ignore`); naming an ignored
+  directory outright (`FROM './dist'`) still scans it; declared tables and
+  watch events are not affected.
+
+#### Verification
+
+```bash
+mkdir -p /tmp/dirsql-gitignore-check/dist
+printf 'dist/\n' > /tmp/dirsql-gitignore-check/.gitignore
+touch /tmp/dirsql-gitignore-check/dist/bundle.js /tmp/dirsql-gitignore-check/app.js
+cd /tmp/dirsql-gitignore-check
+dirsql "SELECT path FROM './' ORDER BY path"
+# expected: [{"path":".gitignore"},{"path":"app.js"}]
+dirsql "SELECT path FROM './' ORDER BY path" --no-ignore
+# expected: [{"path":".gitignore"},{"path":"app.js"},{"path":"dist/bundle.js"}]
+```

dirsql-0.4.7/packages/rust/migrations.d/2026-08-03-nested-default-ignores.md

@@ -0,0 +1,46 @@
+### Default path-table ignores apply at any depth (#741)
+
+#### Summary
+
+The built-in path-table skip rules were anchored at the table root
+(`node_modules/**`, `.git/**`), so a `node_modules` or `.git` nested below a
+subdirectory leaked into path-table query results. The defaults are now
+`**/node_modules/**` and `**/.git/**`, matching at any depth (globset's
+`**/foo` also matches a top-level `foo`, so root-level behavior is
+unchanged). No API signature changes — this changes query results only.
+
+#### Required changes
+
+_None._
+
+#### Deprecations removed
+
+_None._
+
+#### Behavior changes without code changes
+
+- Path-table scans (`FROM './'`, `FROM './dir'`, absolute and `~/` forms):
+  previously files under a *nested* `node_modules/` or `.git/` (e.g.
+  `apps/site/node_modules/pkg/index.js`) appeared in results; now they are
+  skipped like their top-level counterparts. Queries that relied on nested
+  `node_modules`/`.git` contents surfacing implicitly must name the
+  directory outright (`FROM './apps/site/node_modules'`), which still scans
+  it — the skip rules continue to apply only beneath the literal path you
+  write.
+- The walker now prunes wholly-ignored directories during traversal instead
+  of filtering matches afterwards, so ignored trees are no longer read at
+  all. Results are identical apart from the nested-skip fix; large ignored
+  trees simply scan faster.
+
+#### Verification
+
+```bash
+mkdir -p /tmp/d741/sub/node_modules
+echo x > /tmp/d741/sub/node_modules/x.txt
+echo y > /tmp/d741/sub/real.txt
+cd /tmp/d741
+dirsql "SELECT path FROM './'"
+# expected: [{"path":"sub/real.txt"}]  (no node_modules row)
+dirsql "SELECT path FROM './sub/node_modules'"
+# expected: [{"path":"sub/node_modules/x.txt"}]  (named outright, still scans)
+```

{dirsql-0.4.6 → dirsql-0.4.7}/packages/rust/src/bin/dirsql.rs

@@ -113,17 +113,24 @@ struct ConfigArgs {
     /// Off by default (ephemeral index).
     #[arg(long, num_args = 0..=1)]
     persist: Option<Option<PathBuf>>,
+
+    /// Scan files a `.gitignore` would hide. Path-tables respect `.gitignore`
+    /// files by default (hierarchically, like fd/ripgrep); this flag restores
+    /// the full walk. The built-in skips (`node_modules`/`.git`) and any
+    /// configured `ignore` patterns still apply.
+    #[arg(long = "no-ignore")]
+    no_ignore: bool,
 }
 
 impl ConfigArgs {
-    /// Apply the `--persist [PATH]` flag to a builder. Absent → no change;
-    /// bare `--persist` → persist at the default location; `--persist <path>`
-    /// → persist at `<path>`.
-    fn apply_persist(&self, mut builder: dirsql::DirSQLBuilder) -> dirsql::DirSQLBuilder {
+    /// 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 {
         if let Some(path) = &self.persist {
             builder = builder.persist(path.as_ref());
         }
-        builder
+        builder.no_ignore(self.no_ignore)
     }
 
     /// The config paths passed via `-c`/`--config`. Empty when none were given
@@ -460,7 +467,7 @@ fn load_state(cfg: &ConfigArgs, path_table_parser: Option<String>) -> AppState {
             .extensions(parse_extension_specs(&cfg.extension))
             .suppress_config_extensions(true);
     }
-    builder = cfg.apply_persist(builder);
+    builder = cfg.apply_index_flags(builder);
     // `--on-file` touches path-tables only: config `[[table]]` definitions keep
     // their own `on-file` hooks; a path-table named in the query gets this
     // parser regardless of any `-c`.
@@ -573,7 +580,7 @@ fn load_configless_state(cfg: &ConfigArgs, path_table_parser: Option<String>) ->
         }
     };
 
-    let mut builder = cfg.apply_persist(DirSQL::builder().root(root));
+    let mut builder = cfg.apply_index_flags(DirSQL::builder().root(root));
     if let Some(command) = path_table_parser {
         builder = builder.path_table_parser(command);
     }
@@ -823,6 +830,23 @@ mod tests {
         );
     }
 
+    #[test]
+    fn no_ignore_flag_defaults_false() {
+        let cli = Cli::parse_from(["dirsql"]);
+        assert!(!cli.common.no_ignore);
+    }
+
+    #[test]
+    fn no_ignore_flag_sets_true_in_the_default_query_mode() {
+        let cli = Cli::parse_from(["dirsql", "SELECT 1", "--no-ignore"]);
+        assert!(cli.common.no_ignore);
+    }
+
+    #[test]
+    fn no_ignore_flag_parses_after_the_query_subcommand() {
+        assert!(query_common(&["dirsql", "query", "SELECT 1", "--no-ignore"]).no_ignore);
+    }
+
     #[test]
     fn persist_flag_parses_after_the_query_subcommand() {
         // Subcommand-local (#609); the flag sits after the positional SQL to