Ship floating launcher, automatic discovery and bounded media search improvements

crates/searchi-service/tests/relevance_google_cpu.rs

@@ -0,0 +1,122 @@
+//! Actual query retrieval against the owned, verified README fixture index.
+use anyhow::{Context, Result};
+use searchi_service::{HybridSearch, SearchOptions};
+use std::path::PathBuf;
+
+fn required(name: &str) -> Result<PathBuf> {
+    std::env::var_os(name)
+        .map(PathBuf::from)
+        .with_context(|| format!("Set {name}"))
+}
+
+#[test]
+#[ignore = "Requires verified owned README fixture database and actual Google CPU model/runtime"]
+fn real_google_hybrid_shortlist_removes_unrelated_media_without_changing_raw_search() -> Result<()>
+{
+    assert_eq!(std::env::var("SEARCHI_FORCE_CPU")?, "1");
+    let db = required("SEARCHI_TEST_RELEVANCE_DATABASE")?;
+    let model = required("SEARCHI_GEMMA_MODEL_DIR")?;
+    let worker = required("SEARCHI_GEMMA_WORKER")?;
+    let mut search = HybridSearch::open_query(db, model, worker, 1)?;
+    let options = SearchOptions::default();
+    let contract = "cancel the supplier partnership";
+    let raw = search.search_semantic(contract, 50, &options)?;
+    assert_eq!(raw[0].filename, "Supplier Agreement.pdf");
+    assert!(raw
+        .iter()
+        .any(|result| result.filename == "Mountain Lake.jpg"));
+    let measured = search.search_measured(contract, 50, &options, true)?;
+    assert_eq!(measured.results[0].filename, "Supplier Agreement.pdf");
+    assert!(measured.results.iter().all(
+        |result| result.filename != "Mountain Lake.jpg" && result.filename != "Night Pier.jpg"
+    ));
+    assert!(measured
+        .metrics
+        .trace
+        .as_ref()
+        .context("debug trace")?
+        .iter()
+        .any(|span| span.name == "hybrid.semantic_shortlist"
+            && span
+                .counters
+                .get("tail_candidates_pruned")
+                .is_some_and(|count| *count > 0)));
+    let raw_after = search.search_semantic(contract, 50, &options)?;
+    assert_eq!(raw_after.len(), raw.len());
+    assert_eq!(raw_after[0].score, raw[0].score);
+    let image = search.search("mountains reflected in calm water", 50, &options)?;
+    assert_eq!(image[0].filename, "Mountain Lake.jpg");
+    assert!(image
+        .iter()
+        .all(|result| result.match_kind == "semantic_image"));
+    assert_eq!(
+        search.search("Mountain Lake.jpg", 1, &options)?[0].match_kind,
+        "exact_filename"
+    );
+    let pdf = SearchOptions {
+        extension: Some("pdf".into()),
+        ..Default::default()
+    };
+    assert!(search
+        .search(contract, 50, &pdf)?
+        .iter()
+        .all(|result| result.filename == "Supplier Agreement.pdf"));
+    assert_eq!(
+        search.search(contract, 1, &options)?[0].filename,
+        "Supplier Agreement.pdf"
+    );
+    let excluded = SearchOptions {
+        max_size: Some(1),
+        ..Default::default()
+    };
+    assert!(search.search(contract, 50, &excluded)?.is_empty());
+    eprintln!(
+        "actual raw contract candidates={}, hybrid={}, image={}",
+        raw.len(),
+        measured.results.len(),
+        image.len()
+    );
+    Ok(())
+}
+
+#[test]
+#[ignore = "Requires the owned verified README fixture database and real Google CPU runtime"]
+fn real_google_query_warms_during_an_owned_wal_writer() -> Result<()> {
+    assert_eq!(std::env::var("SEARCHI_FORCE_CPU")?, "1");
+    let db = required("SEARCHI_TEST_RELEVANCE_DATABASE")?;
+    let model = required("SEARCHI_GEMMA_MODEL_DIR")?;
+    let worker = required("SEARCHI_GEMMA_WORKER")?;
+    let mut writer = rusqlite::Connection::open(&db)?;
+    let old_dirty: i64 = writer.query_row(
+        "SELECT dirty FROM name_statistics_state WHERE singleton=1",
+        [],
+        |row| row.get(0),
+    )?;
+    writer.execute(
+        "UPDATE name_statistics_state SET dirty=1 WHERE singleton=1",
+        [],
+    )?;
+    let transaction = writer.transaction_with_behavior(rusqlite::TransactionBehavior::Immediate)?;
+    let outcome = (|| -> Result<()> {
+        let mut search = HybridSearch::open_query(&db, model, worker, 1)?;
+        search.warmup()?;
+        let hits = search.search_semantic(
+            "cancel the supplier partnership",
+            1,
+            &SearchOptions::default(),
+        )?;
+        assert_eq!(hits[0].filename, "Supplier Agreement.pdf");
+        assert_eq!(
+            search.worker_info().context("real worker info")?.device,
+            "cpu"
+        );
+        eprintln!("Actual Google CPU query initialization, warmup and prepared retrieval succeeded with the WAL writer held");
+        Ok(())
+    })();
+    transaction.rollback()?;
+    writer.execute(
+        "UPDATE name_statistics_state SET dirty=?1 WHERE singleton=1",
+        [old_dirty],
+    )?;
+    outcome
+}

crates/searchi-service/tests/routing_google_cpu.rs

@@ -3,6 +3,69 @@ use searchi_core::SearchIndex;
 use searchi_service::{FfmpegTools, HybridSearch, MediaLimits, SearchOptions, SemanticOrigin};
 use std::{fs, path::PathBuf};
 
+#[test]
+#[ignore = "Requires verified Google CPU worker/model and FFmpeg fixtures"]
+fn explicit_media_requests_do_not_fall_back_to_unrelated_channels() -> Result<()> {
+    assert_eq!(std::env::var("SEARCHI_FORCE_CPU")?, "1");
+    let model = std::env::var_os("SEARCHI_GEMMA_MODEL_DIR").expect("Set model directory");
+    let worker = std::env::var_os("SEARCHI_GEMMA_WORKER").expect("Set worker path");
+    let tools = FfmpegTools {
+        ffmpeg: std::env::var_os("SEARCHI_TEST_FFMPEG")
+            .expect("Set FFmpeg")
+            .into(),
+        ffprobe: std::env::var_os("SEARCHI_TEST_FFPROBE")
+            .expect("Set FFprobe")
+            .into(),
+    };
+    let fixture =
+        PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../../fixtures/media/assets/image01.jpg");
+    let temp = tempfile::tempdir()?;
+    let corpus = temp.path().join("corpus");
+    fs::create_dir(&corpus)?;
+    fs::copy(fixture, corpus.join("cat.jpg"))?;
+    let database = temp.path().join("index.db");
+    let mut lexical = SearchIndex::open(&database)?;
+    lexical.index_folder(&corpus)?;
+    let mut indexer = HybridSearch::open(&database, &model, &worker, 1)?;
+    let report = indexer.index_embeddings_with_media(&tools, &MediaLimits::default())?;
+    assert!(report.failures.is_empty(), "{report:?}");
+    assert_eq!(report.media_files, 1);
+    drop(indexer);
+    let mut search = HybridSearch::open_query(&database, &model, &worker, 1)?;
+    let options = SearchOptions::default();
+    // The unfiltered real model does return the nearest photo for these requests.
+    // The correction rejects its wrong channel, not its similarity score.
+    for query in [
+        "music with violin",
+        "audio of thunder",
+        "someone mentions a contract",
+        "video of a boat",
+        "Musik mit Klavier",
+        "Film mit einem Wasserfall",
+    ] {
+        assert!(
+            !search
+                .search_semantic_with_origin(query, 10, &options, SemanticOrigin::All)?
+                .is_empty(),
+            "{query}"
+        );
+        assert!(
+            search.search_semantic(query, 10, &options)?.is_empty(),
+            "{query}"
+        );
+    }
+    for query in ["photo of a cat indoors", "Bild einer Katze", "cat indoors"] {
+        let hits = search.search_semantic(query, 10, &options)?;
+        assert_eq!(hits[0].filename, "cat.jpg", "{query}");
+        assert_eq!(hits[0].match_kind, "semantic_image", "{query}");
+    }
+    assert_eq!(
+        search.search("cat.jpg", 1, &options)?[0].match_kind,
+        "exact_filename"
+    );
+    Ok(())
+}
+
 #[test]
 #[ignore = "Requires verified Google CPU worker/model and FFmpeg fixtures"]
 fn explicit_code_intent_preserves_code_among_real_audio_candidates() -> Result<()> {