Tooling: Add index DB query tool

- For a long time we've had a need for this tool, finally we have it!
- With docs

Author: vdavid

AGENTS.md

@@ -61,6 +61,9 @@ Core structure:
   `~/Library/Logs/com.veszelovszki.cmdr/`. Full reference with `RUST_LOG` recipes:
   [docs/tooling/logging.md](docs/tooling/logging.md).
 - **Hot reload**: `pnpm dev` hot-reloads. Max 15s for Rust, max 3s for frontend.
+- **Index DB queries**: The index SQLite DB uses a custom `platform_case` collation, so the `sqlite3` CLI can't query
+  it. Use `cargo run --bin index_query -- <db_path> "<sql>"` instead. See
+  [`src-tauri/src/bin/CLAUDE.md`](apps/desktop/src-tauri/src/bin/CLAUDE.md) for examples and DB paths.
 
 ## MCP
 

apps/desktop/src-tauri/Cargo.toml

@@ -16,6 +16,10 @@ automation = ["dep:tauri-plugin-automation"]
 name = "Cmdr"
 path = "src/main.rs"
 
+[[bin]]
+name = "index_query"
+path = "src/bin/index_query.rs"
+
 # See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html
 
 [lib]

apps/desktop/src-tauri/src/bin/CLAUDE.md

@@ -0,0 +1,33 @@
+# Dev binaries
+
+Cargo binary targets that depend on `cmdr_lib`. Source lives here because Cargo requires `[[bin]]` sources under the package root.
+
+## index_query
+
+Query the drive index SQLite database with the `platform_case` collation registered. The standard `sqlite3` CLI can't query these DBs because the custom collation isn't available.
+
+```sh
+cargo run --bin index_query -- <db_path> "<sql>"
+```
+
+DB paths:
+- **Dev**: `~/Library/Application Support/com.veszelovszki.cmdr-dev/index-root.db`
+- **Prod**: `~/Library/Application Support/com.veszelovszki.cmdr/index-root.db`
+
+Examples:
+
+```sh
+# List top-level directories
+cargo run --bin index_query -- ~/Library/Application\ Support/com.veszelovszki.cmdr-dev/index-root.db \
+  "SELECT e.id, e.name, ds.recursive_size FROM entries e LEFT JOIN dir_stats ds ON ds.entry_id = e.id WHERE e.parent_id = 1 AND e.is_directory = 1 ORDER BY e.name"
+
+# Check dir_stats coverage
+cargo run --bin index_query -- ~/Library/Application\ Support/com.veszelovszki.cmdr-dev/index-root.db \
+  "SELECT (SELECT count(*) FROM dir_stats) as has_stats, (SELECT count(*) FROM entries WHERE is_directory = 1) as total_dirs"
+
+# Walk a specific path (resolve component by component)
+cargo run --bin index_query -- ~/Library/Application\ Support/com.veszelovszki.cmdr-dev/index-root.db \
+  "SELECT id, name FROM entries WHERE parent_id = 1 AND name = 'Users'"
+```
+
+Output is tab-separated with a header row (like `sqlite3` default mode).

apps/desktop/src-tauri/src/bin/index_query.rs

@@ -0,0 +1,49 @@
+//! Minimal CLI to query the Cmdr index SQLite database.
+//!
+//! The index DB uses a custom `platform_case` collation on the `name` column,
+//! so the standard `sqlite3` CLI can't query it. This tool registers the
+//! collation and runs an arbitrary SQL query.
+//!
+//! Usage: cargo run --bin index_query -- <db_path> <sql>
+
+use rusqlite::{Connection, OpenFlags};
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() != 3 {
+        eprintln!("Usage: {} <db_path> <sql>", args[0]);
+        std::process::exit(1);
+    }
+    let db_path = &args[1];
+    let sql = &args[2];
+
+    let conn =
+        Connection::open_with_flags(db_path, OpenFlags::SQLITE_OPEN_READ_ONLY).expect("Couldn't open database");
+    cmdr_lib::indexing::store::register_platform_case_collation(&conn).expect("Couldn't register collation");
+
+    let mut stmt = conn.prepare(sql).expect("Couldn't prepare statement");
+    let column_count = stmt.column_count();
+
+    // Print header row
+    let headers: Vec<&str> = (0..column_count).map(|i| stmt.column_name(i).unwrap_or("?")).collect();
+    println!("{}", headers.join("\t"));
+
+    // Print data rows
+    let mut rows = stmt.query([]).expect("Couldn't execute query");
+    while let Some(row) = rows.next().expect("Couldn't read row") {
+        let values: Vec<String> = (0..column_count)
+            .map(|i| {
+                row.get::<_, rusqlite::types::Value>(i)
+                    .map(|v| match v {
+                        rusqlite::types::Value::Null => "NULL".to_string(),
+                        rusqlite::types::Value::Integer(n) => n.to_string(),
+                        rusqlite::types::Value::Real(f) => f.to_string(),
+                        rusqlite::types::Value::Text(s) => s,
+                        rusqlite::types::Value::Blob(b) => format!("<blob {} bytes>", b.len()),
+                    })
+                    .unwrap_or_else(|_| "ERROR".to_string())
+            })
+            .collect();
+        println!("{}", values.join("\t"));
+    }
+}

apps/desktop/src-tauri/src/indexing/store.rs

@@ -205,7 +205,7 @@ impl std::error::Error for IndexStoreError {}
 ///
 /// Must be called on every connection before any table creation or query,
 /// because custom collations are not persisted in the DB file.
-fn register_platform_case_collation(conn: &Connection) -> Result<(), IndexStoreError> {
+pub fn register_platform_case_collation(conn: &Connection) -> Result<(), IndexStoreError> {
     conn.create_collation("platform_case", platform_case_compare)?;
     Ok(())
 }

apps/desktop/src-tauri/src/lib.rs

@@ -80,7 +80,7 @@ mod file_system;
 pub(crate) mod file_viewer;
 mod font_metrics;
 pub mod icons;
-mod indexing;
+pub mod indexing;
 pub mod licensing;
 #[cfg(target_os = "linux")]
 pub(crate) mod linux_distro;

docs/architecture.md

@@ -122,6 +122,7 @@ Dev workflow docs and external service references. All in `docs/tooling/`.
 |-----|---------|
 | [logging.md](tooling/logging.md) | Unified logging, `RUST_LOG` recipes for every subsystem |
 | [css-health-checks.md](tooling/css-health-checks.md) | Stylelint + Go-based unused CSS checker |
+| [src-tauri/src/bin/CLAUDE.md](../apps/desktop/src-tauri/src/bin/CLAUDE.md) | `index_query` — query index DB with `platform_case` collation (`sqlite3` can't) |
 
 The check runner and E2E testing docs live colocated with their code:
 - Check runner: [`scripts/check/CLAUDE.md`](../scripts/check/CLAUDE.md)