log::debug!("AI server: starting llama-server on port {port} with context size {}", m.context_size);

if let Ok(output) = std::process::Command::new("pgrep")

.arg("-f")

.arg(&*binary_str)

.output()

{

| `search.rs` | Drive search | `prepare_search_index`, `search_files`, `release_search_index`, `translate_search_query`, `parse_search_scope`. Thin wrappers over `indexing::search` module. Post-filters directory sizes after `fill_directory_sizes`. AI search uses single-pass classification prompt → `ai_response_parser` → `ai_query_builder` pipeline. |

| `ai_response_parser.rs` | AI search parser | Key-value line parser for LLM classification responses. Validates enum fields, extracts keywords. Fallback keyword extraction when LLM fails. |

| `ai_query_builder.rs` | AI search builder | Maps parsed LLM enums (type, time, size, scope) into `SearchQuery` fields. Merges keywords + type into single regex pattern. Deterministic date/size computation. |

pub mod ai_query_builder;

pub mod ai_response_parser;

use crate::indexing::search::{

use super::ai_query_builder;

use super::ai_response_parser;

pub(crate) fn iso_date_to_timestamp(date_str: &str) -> Result<u64, String> {

let format = time::macros::format_description!("[year]-[month]-[day]");

let date = time::Date::parse(date_str, &format).map_err(|e| format!("Invalid date '{date_str}': {e}"))?;

let datetime = date.with_hms(0, 0, 0).expect("midnight is always valid");

let timestamp = datetime.assume_utc().unix_timestamp();

if timestamp < 0 {

return Err(format!("Date '{date_str}' is before unix epoch"));

}

Ok(timestamp as u64)

const CLASSIFICATION_PROMPT: &str = "\

fn build_classification_prompt() -> String {

let today = time::OffsetDateTime::now_utc().date();

let format = time::macros::format_description!("[year]-[month]-[day]");

let today_str = today.format(&format).expect("date format always succeeds");

CLASSIFICATION_PROMPT.replace("{TODAY}", &today_str)

let system_prompt = build_classification_prompt();

let parsed = ai_response_parser::parse_llm_response(&response);

let fallback_kw = ai_response_parser::fallback_keywords(&natural_query);

ai_response_parser::ParsedLlmResponse {

#[test]

fn test_iso_date_to_timestamp() {

// 2025-01-01 00:00:00 UTC = 1735689600

let ts = iso_date_to_timestamp("2025-01-01").unwrap();

assert_eq!(ts, 1_735_689_600);

}

#[test]

fn test_iso_date_to_timestamp_mid_year() {

// 2026-06-15 00:00:00 UTC = 1781481600

let ts = iso_date_to_timestamp("2026-06-15").unwrap();

assert_eq!(ts, 1_781_481_600);

}

#[test]

fn test_iso_date_to_timestamp_invalid() {

assert!(iso_date_to_timestamp("not-a-date").is_err());

assert!(iso_date_to_timestamp("2025-13-01").is_err());

assert!(iso_date_to_timestamp("2025-01-32").is_err());

}

#[test]

fn test_classification_prompt_contains_date() {

let prompt = build_classification_prompt();

assert!(prompt.contains("Today:"));

assert!(prompt.contains("Extract search parameters"));

// Should contain a date in YYYY-MM-DD format

assert!(prompt.contains("20")); // Year starts with 20

}

#[test]

fn test_classification_prompt_contains_type_enums() {

let prompt = build_classification_prompt();

assert!(prompt.contains("photos|screenshots|videos"));

assert!(prompt.contains("shell-scripts|ssh-keys|docker-compose|env-files"));

}

#[test]

fn test_classification_prompt_contains_time_enums() {

let prompt = build_classification_prompt();

assert!(prompt.contains("last_3_months|last_6_months"));

}

- **search.rs** -- In-memory search index for whole-drive file search. Lazily loads all entries from the index DB into a `Vec<SearchEntry>` for fast parallel scanning with rayon. Filenames are arena-allocated: all names are concatenated into a single `SearchIndex.names: String` buffer, and each `SearchEntry` stores `name_offset: u32` + `name_len: u16` instead of an owned `String`. During load, `row.get_ref(col).as_str()` borrows directly from SQLite's internal buffer (zero per-row heap allocations), then pushes into the arena. `name_folded` is NOT stored in the search index — instead, the search pattern is NFD-normalized at query time on macOS (APFS filenames are already NFD). `SearchIndex::name(&self, entry)` retrieves a `&str` slice from the arena. `search()` is a pure function: compiles glob/regex patterns, parallel-filters entries, sorts by recency. Global `SEARCH_INDEX` state with `Arc<SearchIndex>`, idle timer (5 min after dialog close), backstop timer (10 min with no activity), and load cancellation via `AtomicBool` checked every 100K rows. `WRITER_GENERATION` in writer.rs tracks mutations; stale indexes are detected on search. Scope filtering: `SearchQuery` accepts optional `include_paths` (absolute paths — search only within these subtrees) and `exclude_dir_names` (directory names/patterns to exclude at any depth). Include paths are resolved to entry IDs via `store::resolve_path()` (SQLite indexed lookups, microseconds) at the call site before `search()`, stored in `include_path_ids`. `prepare_scope_filter()` reads pre-resolved IDs and compiles exclude patterns as regexes. `ScopeFilter::matches()` walks the ancestor chain via `id_to_index` (O(1) per level) after all other filters pass. `parse_scope()` parses a user-typed comma-separated scope string (with quoting, escaping, `~` expansion, `!` excludes) into a `ParsedScope` struct. IPC commands in `commands/search.rs`: `prepare_search_index` (emits `search-index-ready` event when load completes), `search_files`, `release_search_index`, `translate_search_query` (AI natural language → structured query), `parse_search_scope` (scope string → structured `ParsedScope`).

pub(crate) mod search;

use crate::indexing::search::PatternType;

use crate::indexing::search::{

.map(crate::commands::search::iso_date_to_timestamp)

.map(crate::commands::search::iso_date_to_timestamp)

use crate::indexing::search::SearchResultEntry;

use crate::indexing::search::SearchResultEntry;