feat: add desktop document search and verified native CPU embeddings

apps/desktop/README.md

@@ -0,0 +1,29 @@
+# Searchi desktop
+
+This Tauri 2 shell calls the same Rust core as the CLI. It provides real folder indexing, native folder selection, filename/content search, folder/extension/size/date filters, keyboard navigation, escaped text previews, and native open/reveal actions. There are no mocked results or embeddings. Semantic retrieval, a global shortcut, watchers, and release installers remain roadmap work.
+
+## Develop
+
+Install Node.js LTS, Rust stable, and the platform prerequisites documented at https://v2.tauri.app/start/prerequisites/. Windows requires MSVC build tools and WebView2; Linux requires WebKitGTK and system development packages; macOS requires Xcode command line tools.
+
+```sh
+cd apps/desktop
+npm ci
+npm run build
+npm run tauri dev
+```
+
+`npm run dev` previews layout in a browser but cannot index or search files. The app reports this limitation explicitly. Press Ctrl+K (Cmd+K on macOS) to focus search; arrow keys navigate results. Choose a folder through the native dialog or enter an absolute path. Open/reveal commands canonicalize the path, verify it is a current file, and require exact membership in the index. The webview has no general opener or filesystem capability. Page/paragraph source locations are displayed when supplied by the core; opening at that exact location is future work.
+
+The desktop index is stored in the platform app-data directory under `dev.searchi.desktop`. Search opens independent core connections while indexing runs on a blocking worker; a guard limits this shell to one indexing job at a time. All model testing on the Windows VM must remain CPU only. This shell configures no GPU provider.
+
+For Windows VM UI testing, disable WebView2 GPU rendering as well, before starting Tauri in PowerShell:
+
+```powershell
+$env:WEBVIEW2_ADDITIONAL_BROWSER_ARGUMENTS = '--disable-gpu'
+npm.cmd run tauri dev
+```
+
+## Verification and packaging
+
+`npm run build` checks strict TypeScript and creates production frontend assets. `npm run tauri build -- --no-bundle` compiles the native shell when platform prerequisites are installed. Installer bundling is intentionally disabled until release icons, signing and native platform checks are complete. Native Windows, macOS, and Linux checks must be recorded separately; a frontend build does not prove the native shell works.

apps/desktop/index.html

@@ -0,0 +1,12 @@
+<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="UTF-8" />
+    <meta name="viewport" content="width=device-width,initial-scale=1" />
+    <title>Searchi</title>
+  </head>
+  <body>
+    <div id="app"></div>
+    <script type="module" src="/src/main.ts"></script>
+  </body>
+</html>

apps/desktop/package.json

@@ -0,0 +1,22 @@
+{
+  "name": "searchi-desktop",
+  "version": "0.1.0",
+  "private": true,
+  "type": "module",
+  "scripts": {
+    "dev": "vite --host 127.0.0.1",
+    "build": "tsc --noEmit && vite build",
+    "tauri": "tauri",
+    "format": "prettier --write src index.html vite.config.ts tsconfig.json src-tauri/tauri.conf.json src-tauri/capabilities/default.json",
+    "format:check": "prettier --check src index.html vite.config.ts tsconfig.json src-tauri/tauri.conf.json src-tauri/capabilities/default.json"
+  },
+  "dependencies": {
+    "@tauri-apps/api": "^2.0.0"
+  },
+  "devDependencies": {
+    "@tauri-apps/cli": "^2.0.0",
+    "prettier": "3.6.2",
+    "typescript": "^5.7.0",
+    "vite": "^6.0.0"
+  }
+}

apps/desktop/src-tauri/Cargo.toml

@@ -0,0 +1,24 @@
+[package]
+name = "searchi-desktop"
+version = "0.1.0"
+edition = "2021"
+description = "Local Searchi desktop shell"
+license = "MIT"
+
+[workspace]
+
+[features]
+custom-protocol = ["tauri/custom-protocol"]
+
+[build-dependencies]
+tauri-build = { version = "2", features = [] }
+
+[dependencies]
+tauri = { version = "2", features = [] }
+tauri-plugin-dialog = "2"
+tauri-plugin-opener = "2"
+serde = { version = "1", features = ["derive"] }
+searchi-core = { path = "../../../crates/searchi-core" }
+
+[dev-dependencies]
+tempfile = "3"

apps/desktop/src-tauri/build.rs

@@ -0,0 +1,3 @@
+fn main() {
+    tauri_build::build()
+}

apps/desktop/src-tauri/capabilities/default.json

@@ -0,0 +1,7 @@
+{
+  "$schema": "../gen/schemas/desktop-schema.json",
+  "identifier": "main",
+  "description": "Minimal main-window access; filesystem access is mediated by Searchi commands.",
+  "windows": ["main"],
+  "permissions": ["core:default"]
+}

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

@@ -0,0 +1,220 @@
+#![cfg_attr(not(debug_assertions), windows_subsystem = "windows")]
+
+use searchi_core::{IndexReport, IndexStats, SearchIndex, SearchOptions, SearchResult};
+use serde::Deserialize;
+use std::{
+    path::PathBuf,
+    sync::{
+        atomic::{AtomicBool, Ordering},
+        Arc,
+    },
+};
+use tauri::{Manager, State};
+use tauri_plugin_dialog::DialogExt;
+use tauri_plugin_opener::OpenerExt;
+
+struct AppState {
+    database: PathBuf,
+    indexing: Arc<AtomicBool>,
+}
+
+#[derive(Default, Deserialize)]
+struct Filters {
+    folder: Option<PathBuf>,
+    extension: Option<String>,
+    min_size: Option<u64>,
+    max_size: Option<u64>,
+    modified_after_unix_ms: Option<i64>,
+    modified_before_unix_ms: Option<i64>,
+}
+
+impl From<Filters> for SearchOptions {
+    fn from(value: Filters) -> Self {
+        Self {
+            folder: value.folder,
+            extension: value.extension,
+            min_size: value.min_size,
+            max_size: value.max_size,
+            modified_after_unix_ms: value.modified_after_unix_ms,
+            modified_before_unix_ms: value.modified_before_unix_ms,
+        }
+    }
+}
+
+// Each job owns its connection. Slow indexing never holds a desktop mutex.
+#[tauri::command]
+async fn search(
+    query: String,
+    filters: Option<Filters>,
+    state: State<'_, AppState>,
+) -> Result<Vec<SearchResult>, String> {
+    let database = state.database.clone();
+    tauri::async_runtime::spawn_blocking(move || {
+        SearchIndex::open(database)
+            .and_then(|index| {
+                index.search_with_options(&query, 50, &filters.unwrap_or_default().into())
+            })
+            .map_err(|e| e.to_string())
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+#[tauri::command]
+async fn pick_folder(app: tauri::AppHandle) -> Result<Option<String>, String> {
+    tauri::async_runtime::spawn_blocking(move || {
+        app.dialog()
+            .file()
+            .set_title("Choose a folder to index")
+            .blocking_pick_folder()
+            .map(|path| {
+                path.into_path()
+                    .map(|path| path.to_string_lossy().into_owned())
+                    .map_err(|e| e.to_string())
+            })
+            .transpose()
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+// No broad opener permission is given to the webview. Every action is checked
+// against the index and the current filesystem before invoking a native opener.
+fn validated_result(index: &SearchIndex, path: &str) -> Result<PathBuf, String> {
+    let canonical = std::fs::canonicalize(path).map_err(|e| format!("File is unavailable: {e}"))?;
+    if !canonical.is_file() {
+        return Err("Result is no longer a file.".into());
+    }
+    if !index
+        .contains_path(&canonical.to_string_lossy())
+        .map_err(|e| e.to_string())?
+    {
+        return Err("Only files in your search index can be opened.".into());
+    }
+    Ok(canonical)
+}
+
+#[tauri::command]
+async fn open_result(
+    path: String,
+    reveal: bool,
+    app: tauri::AppHandle,
+    state: State<'_, AppState>,
+) -> Result<(), String> {
+    let database = state.database.clone();
+    tauri::async_runtime::spawn_blocking(move || {
+        let index = SearchIndex::open(database).map_err(|e| e.to_string())?;
+        let canonical = validated_result(&index, &path)?;
+        if reveal {
+            app.opener()
+                .reveal_item_in_dir(canonical)
+                .map_err(|e| e.to_string())
+        } else {
+            app.opener()
+                .open_path(canonical.to_string_lossy().into_owned(), None::<&str>)
+                .map_err(|e| e.to_string())
+        }
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+#[tauri::command]
+async fn stats(state: State<'_, AppState>) -> Result<IndexStats, String> {
+    let database = state.database.clone();
+    tauri::async_runtime::spawn_blocking(move || {
+        SearchIndex::open(database)
+            .and_then(|index| index.stats())
+            .map_err(|e| e.to_string())
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+// Reset the gate on every exit, including extractor failures or task panics.
+struct IndexGuard(Arc<AtomicBool>);
+impl Drop for IndexGuard {
+    fn drop(&mut self) {
+        self.0.store(false, Ordering::Release);
+    }
+}
+
+#[tauri::command]
+async fn index_folder(root: String, state: State<'_, AppState>) -> Result<IndexReport, String> {
+    if state
+        .indexing
+        .compare_exchange(false, true, Ordering::AcqRel, Ordering::Acquire)
+        .is_err()
+    {
+        return Err("A folder is already being indexed. Wait for it to finish.".into());
+    }
+    let guard = IndexGuard(state.indexing.clone());
+    let database = state.database.clone();
+    tauri::async_runtime::spawn_blocking(move || {
+        let _guard = guard;
+        SearchIndex::open(database)
+            .and_then(|mut index| index.index_folder(root))
+            .map_err(|e| e.to_string())
+    })
+    .await
+    .map_err(|e| e.to_string())?
+}
+
+fn main() {
+    tauri::Builder::default()
+        .plugin(tauri_plugin_dialog::init())
+        .plugin(tauri_plugin_opener::init())
+        .setup(|app| {
+            let directory = app.path().app_data_dir()?;
+            std::fs::create_dir_all(&directory)?;
+            let database = directory.join("searchi.sqlite");
+            SearchIndex::open(&database)?;
+            app.manage(AppState {
+                database,
+                indexing: Arc::new(AtomicBool::new(false)),
+            });
+            Ok(())
+        })
+        .invoke_handler(tauri::generate_handler![
+            search,
+            stats,
+            index_folder,
+            pick_folder,
+            open_result
+        ])
+        .run(tauri::generate_context!())
+        .expect("Searchi desktop could not start");
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn indexing_gate_is_released_when_worker_unwinds() {
+        let indexing = Arc::new(AtomicBool::new(true));
+        let gate = indexing.clone();
+        let result = std::panic::catch_unwind(move || {
+            let _guard = IndexGuard(gate);
+            panic!("extractor failure");
+        });
+        assert!(result.is_err());
+        assert!(!indexing.load(Ordering::Acquire));
+    }
+
+    #[test]
+    fn opener_rejects_unindexed_and_deleted_files() {
+        let root = tempfile::tempdir().unwrap();
+        let indexed = root.path().join("indexed.txt");
+        std::fs::write(&indexed, "retrieval fixture").unwrap();
+        let mut index = SearchIndex::open(":memory:").unwrap();
+        index.index_folder(root.path()).unwrap();
+        assert!(validated_result(&index, &indexed.to_string_lossy()).is_ok());
+        let unindexed = root.path().join("new.txt");
+        std::fs::write(&unindexed, "not indexed").unwrap();
+        assert!(validated_result(&index, &unindexed.to_string_lossy()).is_err());
+        std::fs::remove_file(&indexed).unwrap();
+        assert!(validated_result(&index, &indexed.to_string_lossy()).is_err());
+        assert!(validated_result(&index, &root.path().to_string_lossy()).is_err());
+    }
+}

apps/desktop/src-tauri/tauri.conf.json

@@ -0,0 +1,27 @@
+{
+  "$schema": "https://schema.tauri.app/config/2",
+  "productName": "Searchi",
+  "version": "0.1.0",
+  "identifier": "dev.searchi.desktop",
+  "build": {
+    "beforeDevCommand": "npm run dev",
+    "beforeBuildCommand": "npm run build",
+    "devUrl": "http://localhost:1420",
+    "frontendDist": "../dist"
+  },
+  "app": {
+    "windows": [
+      {
+        "title": "Searchi",
+        "width": 1080,
+        "height": 760,
+        "minWidth": 680,
+        "minHeight": 540
+      }
+    ],
+    "security": {
+      "csp": "default-src 'self'; connect-src ipc: http://ipc.localhost; style-src 'self' 'unsafe-inline'; img-src 'self' data:"
+    }
+  },
+  "bundle": { "active": false }
+}

apps/desktop/src/main.ts

@@ -0,0 +1,270 @@
+import { invoke, isTauri } from "@tauri-apps/api/core";
+import "./style.css";
+
+interface SearchResult {
+  path: string;
+  filename: string;
+  snippet: string;
+  score: number;
+  match_kind: string;
+  source?: { kind: string; number: number };
+  extraction_error?: string;
+}
+interface IndexReport {
+  discovered: number;
+  indexed: number;
+  removed: number;
+  skipped: number;
+}
+interface IndexStats {
+  files: number;
+  content_files: number;
+}
+
+document.querySelector<HTMLDivElement>("#app")!.innerHTML = `
+<header><div class="wordmark">searchi<span class="dot">.</span></div><span class="privacy">● Local · CPU only</span></header>
+<main><section class="intro"><p class="eyebrow">YOUR FILES, WITHIN REACH</p><h1>Find the thing you remember.</h1><p>Search filenames and document content in your selected folders.</p></section>
+<form id="search-form" role="search"><label class="sr-only" for="query">Search your files</label><span class="search-icon" aria-hidden="true">⌕</span><input id="query" type="search" placeholder="A filename or words from a document…" autocomplete="off" spellcheck="false" maxlength="1000"><kbd>Ctrl K</kbd></form>
+<div class="toolbar"><span id="index-status">Loading your index…</span><button id="add-folder" type="button">+ Index a folder</button></div>
+<details id="filters"><summary>Filter results</summary><div class="filters-grid"><label>Within folder<input id="filter-folder" placeholder="Absolute folder path"></label><label>Extension<input id="filter-extension" placeholder="pdf, md, txt…"></label><label>Minimum size (bytes)<input id="filter-min" type="number" min="0" step="1"></label><label>Maximum size (bytes)<input id="filter-max" type="number" min="0" step="1"></label><label>Modified from<input id="filter-after" type="date"></label><label>Modified through<input id="filter-before" type="date"></label></div></details>
+<form id="folder-form" hidden><label for="folder">Folder to index</label><div class="folder-row"><input id="folder" placeholder="Absolute folder path" required><button id="browse-folder" type="button">Browse…</button><button type="submit">Index folder</button><button id="cancel-folder" type="button">Cancel</button></div><p class="hint">Only choose folders you want searched. Large folders may take a while.</p></form>
+<p id="notice" role="status" aria-live="polite"></p><div class="workspace"><section aria-label="Search results"><p id="result-summary" class="eyebrow">READY WHEN YOU ARE</p><ul id="results" aria-label="Matching files"></ul><div id="empty"><span aria-hidden="true">⌕</span><h2>Your next discovery starts here.</h2><p>Index a folder, then search a filename or a phrase from a document.</p></div></section><aside id="preview" aria-label="Result preview" hidden><p class="eyebrow">CONTENT PREVIEW</p><h2 id="preview-title"></h2><p id="preview-path" class="path"></p><p id="preview-kind"></p><div class="preview-actions"><button id="open-result" type="button">Open file</button><button id="reveal-result" type="button">Show in folder</button></div><pre id="preview-text"></pre></aside></div>
+</main><footer>Offline by default<span>↑ ↓ Navigate · Enter Preview · Esc Clear</span></footer>`;
+
+const element = <T extends HTMLElement>(id: string) =>
+  document.getElementById(id) as T;
+const query = element<HTMLInputElement>("query");
+const list = element<HTMLUListElement>("results");
+const notice = element<HTMLParagraphElement>("notice");
+let results: SearchResult[] = [];
+let selected = -1;
+let requestId = 0;
+let timer: ReturnType<typeof setTimeout>;
+
+function showError(error: unknown) {
+  notice.textContent = String(error);
+  notice.className = "error";
+}
+function select(index: number, focus = false) {
+  if (!results.length) return;
+  selected = Math.max(0, Math.min(index, results.length - 1));
+  const result = results[selected];
+  list.querySelectorAll<HTMLButtonElement>("button").forEach((button, i) => {
+    button.classList.toggle("selected", i === selected);
+    button.setAttribute("aria-pressed", String(i === selected));
+    if (i === selected && focus) button.focus();
+  });
+  element("preview").hidden = false;
+  element("preview-title").textContent = result.filename;
+  element("preview-path").textContent = result.path;
+  element("preview-kind").textContent =
+    `${result.match_kind} match${result.source ? ` · ${result.source.kind} ${result.source.number}` : ""}`;
+  element("preview-text").textContent =
+    result.snippet ||
+    (result.extraction_error
+      ? `Content could not be extracted: ${result.extraction_error}`
+      : "No extracted text is available for this file.");
+}
+
+function render() {
+  list.replaceChildren();
+  element("empty").hidden = results.length > 0;
+  element("preview").hidden = true;
+  results.forEach((result, i) => {
+    const row = document.createElement("li");
+    const button = document.createElement("button");
+    button.className = "result";
+    button.type = "button";
+    const title = document.createElement("strong");
+    title.textContent = result.filename;
+    const path = document.createElement("span");
+    path.className = "path";
+    path.textContent = result.path;
+    const snippet = document.createElement("span");
+    snippet.className = "snippet";
+    snippet.textContent = result.snippet;
+    const kind = document.createElement("span");
+    kind.className = "kind";
+    kind.textContent = result.match_kind;
+    button.append(title, kind, path, snippet);
+    button.addEventListener("click", () => select(i));
+    row.append(button);
+    list.append(row);
+  });
+  if (results.length) select(0);
+}
+
+async function search() {
+  const id = ++requestId;
+  const value = query.value.trim();
+  if (!value) {
+    results = [];
+    render();
+    element("result-summary").textContent = "READY WHEN YOU ARE";
+    element("empty").querySelector("h2")!.textContent =
+      "Your next discovery starts here.";
+    element("empty").querySelector("p")!.textContent =
+      "Index a folder, then search a filename or a phrase from a document.";
+    return;
+  }
+  element("result-summary").textContent = "SEARCHING…";
+  const started = performance.now();
+  try {
+    const input = (id: string) => element<HTMLInputElement>(id).value.trim();
+    const size = (id: string) => {
+      const text = input(id);
+      if (!text) return null;
+      const value = Number(text);
+      if (!Number.isSafeInteger(value) || value < 0)
+        throw new Error(
+          "File size must be a nonnegative whole number of bytes.",
+        );
+      return value;
+    };
+    // Date controls represent the user's local calendar day, including its end.
+    const date = (id: string, end: boolean) => {
+      const text = input(id);
+      if (!text) return null;
+      const stamp = new Date(
+        `${text}T${end ? "23:59:59.999" : "00:00:00"}`,
+      ).getTime();
+      if (!Number.isFinite(stamp))
+        throw new Error("Enter a valid modification date.");
+      return stamp;
+    };
+    const found = await invoke<SearchResult[]>("search", {
+      query: value,
+      filters: {
+        folder: input("filter-folder") || null,
+        extension: input("filter-extension") || null,
+        min_size: size("filter-min"),
+        max_size: size("filter-max"),
+        modified_after_unix_ms: date("filter-after", false),
+        modified_before_unix_ms: date("filter-before", true),
+      },
+    });
+    if (id !== requestId) return;
+    results = found;
+    selected = -1;
+    render();
+    element("result-summary").textContent =
+      `${found.length} RESULTS · ${Math.round(performance.now() - started)} MS`;
+    if (!found.length) {
+      element("empty").querySelector("h2")!.textContent =
+        "No matching files yet.";
+      element("empty").querySelector("p")!.textContent =
+        "Try a shorter phrase, an exact filename, or index another folder.";
+    }
+  } catch (error) {
+    if (id === requestId) {
+      showError(error);
+      element("result-summary").textContent = "SEARCH FAILED";
+    }
+  }
+}
+
+async function refreshStats() {
+  const stats = await invoke<IndexStats>("stats");
+  element("index-status").textContent =
+    `${stats.files.toLocaleString()} files · ${stats.content_files.toLocaleString()} with searchable content`;
+}
+
+query.addEventListener("input", () => {
+  ++requestId;
+  clearTimeout(timer);
+  timer = setTimeout(search, 100);
+});
+element("search-form").addEventListener("submit", (event) => {
+  event.preventDefault();
+  clearTimeout(timer);
+  void search();
+});
+element("add-folder").addEventListener("click", () => {
+  element("folder-form").hidden = false;
+  element("folder").focus();
+});
+element("cancel-folder").addEventListener("click", () => {
+  element("folder-form").hidden = true;
+  query.focus();
+});
+element("browse-folder").addEventListener("click", async () => {
+  try {
+    const folder = await invoke<string | null>("pick_folder");
+    if (folder) element<HTMLInputElement>("folder").value = folder;
+  } catch (error) {
+    showError(error);
+  }
+});
+element("filters").addEventListener("change", () => {
+  ++requestId;
+  clearTimeout(timer);
+  void search();
+});
+async function openSelected(reveal: boolean) {
+  if (selected < 0 || !results[selected]) return;
+  try {
+    await invoke("open_result", { path: results[selected].path, reveal });
+  } catch (error) {
+    showError(error);
+  }
+}
+element("open-result").addEventListener("click", () => {
+  void openSelected(false);
+});
+element("reveal-result").addEventListener("click", () => {
+  void openSelected(true);
+});
+element("folder-form").addEventListener("submit", async (event) => {
+  event.preventDefault();
+  const input = element<HTMLInputElement>("folder");
+  const buttons =
+    element("folder-form").querySelectorAll<HTMLButtonElement>("button");
+  buttons.forEach((button) => {
+    button.disabled = true;
+  });
+  element<HTMLButtonElement>("add-folder").disabled = true;
+  notice.className = "";
+  notice.textContent = "Indexing folder… Search remains available.";
+  try {
+    const report = await invoke<IndexReport>("index_folder", {
+      root: input.value.trim(),
+    });
+    notice.textContent = `Indexed ${report.indexed} files. ${report.removed} removed; ${report.skipped} skipped.`;
+    element("folder-form").hidden = true;
+    await refreshStats();
+    await search();
+  } catch (error) {
+    showError(error);
+  } finally {
+    buttons.forEach((button) => {
+      button.disabled = false;
+    });
+    element<HTMLButtonElement>("add-folder").disabled = false;
+  }
+});
+document.addEventListener("keydown", (event) => {
+  if ((event.ctrlKey || event.metaKey) && event.key.toLowerCase() === "k") {
+    event.preventDefault();
+    query.focus();
+    query.select();
+  }
+  if (event.key === "Escape") {
+    ++requestId;
+    query.value = "";
+    void search();
+    query.focus();
+  }
+  if (event.target === query || list.contains(event.target as Node)) {
+    if (event.key === "ArrowDown" || event.key === "ArrowUp") {
+      event.preventDefault();
+      select(selected + (event.key === "ArrowDown" ? 1 : -1), true);
+    }
+  }
+});
+if (isTauri()) {
+  void refreshStats().catch(showError);
+  query.focus();
+} else {
+  element("index-status").textContent = "Desktop preview";
+  showError("Run the Tauri desktop app to index and search real files.");
+}

apps/desktop/src/style.css

@@ -0,0 +1,343 @@
+:root {
+  font-family:
+    Inter,
+    Segoe UI,
+    system-ui,
+    sans-serif;
+  color: #20332e;
+  background: #f6f7f2;
+  font-synthesis: none;
+  color-scheme: light;
+}
+* {
+  box-sizing: border-box;
+}
+body {
+  margin: 0;
+}
+button,
+input {
+  font: inherit;
+}
+button {
+  cursor: pointer;
+}
+button:disabled {
+  cursor: wait;
+  opacity: 0.6;
+}
+header,
+footer {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  padding: 24px 40px;
+}
+.wordmark {
+  font-size: 28px;
+  font-weight: 750;
+  letter-spacing: -1.5px;
+}
+.dot {
+  color: #87a77f;
+}
+.privacy {
+  font-size: 12px;
+  color: #58705c;
+}
+main {
+  max-width: 1120px;
+  margin: 0 auto;
+  padding: 24px 40px;
+}
+.intro {
+  margin: 12px 0 30px;
+}
+.eyebrow {
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 1.8px;
+  color: #78887c;
+}
+.intro h1 {
+  font-size: clamp(28px, 4vw, 42px);
+  letter-spacing: -1.5px;
+  margin: 12px 0;
+}
+.intro > p:last-child {
+  color: #738077;
+  margin: 0;
+}
+#search-form {
+  display: flex;
+  align-items: center;
+  gap: 16px;
+  background: white;
+  border: 1px solid #d2dccf;
+  border-radius: 14px;
+  padding: 18px 22px;
+  box-shadow: 0 8px 30px #243b2910;
+}
+#query {
+  width: 100%;
+  border: 0;
+  background: transparent;
+  font-size: 19px;
+  color: inherit;
+  outline: none;
+}
+#search-form:focus-within {
+  border-color: #588663;
+  box-shadow: 0 0 0 3px #65866922;
+}
+.search-icon {
+  font-size: 30px;
+  color: #6a8770;
+}
+kbd {
+  white-space: nowrap;
+  color: #829086;
+  font-size: 11px;
+  border: 1px solid #dce3d9;
+  padding: 5px;
+  border-radius: 4px;
+}
+.toolbar {
+  display: flex;
+  justify-content: space-between;
+  align-items: center;
+  margin: 18px 0;
+  font-size: 12px;
+  color: #78847b;
+}
+.toolbar button,
+.folder-row button {
+  background: #e8ede2;
+  border: 1px solid #d9e0d2;
+  padding: 9px 14px;
+  border-radius: 7px;
+  color: #36583c;
+}
+#folder-form {
+  background: #eef2e9;
+  padding: 18px;
+  border-radius: 10px;
+}
+#folder-form label {
+  font-size: 13px;
+  font-weight: 600;
+}
+.folder-row {
+  display: flex;
+  gap: 8px;
+  margin-top: 10px;
+}
+.folder-row input {
+  min-width: 0;
+  flex: 1;
+  padding: 9px;
+  border: 1px solid #c9d3c3;
+  border-radius: 6px;
+}
+.hint {
+  color: #74806e;
+  font-size: 12px;
+}
+.workspace {
+  display: grid;
+  grid-template-columns: minmax(0, 1.3fr) minmax(250px, 1fr);
+  gap: 28px;
+  border-top: 1px solid #e1e6db;
+  padding-top: 20px;
+}
+.workspace:has(aside[hidden]) {
+  grid-template-columns: 1fr;
+}
+#results {
+  list-style: none;
+  padding: 0;
+  margin: 0;
+}
+.result {
+  display: grid;
+  grid-template-columns: 1fr auto;
+  text-align: left;
+  width: 100%;
+  padding: 16px;
+  background: transparent;
+  border: 1px solid transparent;
+  border-radius: 10px;
+  color: inherit;
+  gap: 8px;
+}
+.result:hover {
+  background: #edf1e7;
+}
+.result.selected {
+  background: white;
+  border-color: #d1dbc9;
+  box-shadow: 0 3px 12px #314b2810;
+}
+.result strong {
+  font-size: 14px;
+  overflow-wrap: anywhere;
+}
+.path {
+  font-size: 11px;
+  color: #79847a;
+  overflow-wrap: anywhere;
+}
+.result .path,
+.snippet {
+  grid-column: 1/-1;
+}
+.snippet {
+  font-size: 12px;
+  color: #61705f;
+  display: -webkit-box;
+  -webkit-line-clamp: 2;
+  -webkit-box-orient: vertical;
+  overflow: hidden;
+}
+.kind {
+  font-size: 10px;
+  padding: 3px 7px;
+  border-radius: 5px;
+  background: #e6eddf;
+  color: #638054;
+}
+aside {
+  padding: 18px 22px;
+  border-left: 1px solid #dce3d5;
+  min-width: 0;
+}
+aside h2 {
+  font-size: 20px;
+  overflow-wrap: anywhere;
+}
+aside pre {
+  font: 13px/1.8 inherit;
+  white-space: pre-wrap;
+  overflow-wrap: anywhere;
+}
+#preview-kind {
+  font-size: 12px;
+  color: #67875f;
+}
+#empty {
+  text-align: center;
+  padding: 38px 18px;
+  color: #91a088;
+}
+#empty > span {
+  font-size: 55px;
+}
+#empty h2 {
+  font-size: 20px;
+  font-weight: 500;
+  color: #607358;
+}
+#empty p {
+  font-size: 13px;
+  line-height: 1.6;
+}
+#notice {
+  min-height: 18px;
+  font-size: 12px;
+  color: #627a5c;
+}
+#notice.error {
+  color: #a54639;
+}
+footer {
+  color: #95a18e;
+  font-size: 11px;
+  border-top: 1px solid #e1e6db;
+  margin-top: 32px;
+}
+button:focus-visible,
+input:focus-visible {
+  outline: 2px solid #5b8357;
+  outline-offset: 3px;
+}
+.sr-only {
+  position: absolute;
+  width: 1px;
+  height: 1px;
+  padding: 0;
+  margin: -1px;
+  overflow: hidden;
+  clip: rect(0, 0, 0, 0);
+  white-space: nowrap;
+  border: 0;
+}
+[hidden] {
+  display: none !important;
+}
+@media (max-width: 760px) {
+  header,
+  footer {
+    padding: 20px;
+  }
+  main {
+    padding: 12px 20px;
+  }
+  .workspace {
+    grid-template-columns: 1fr;
+  }
+  aside {
+    border-left: 0;
+    border-top: 1px solid #dce3d5;
+  }
+  .folder-row {
+    flex-wrap: wrap;
+  }
+  .folder-row input {
+    flex-basis: 100%;
+  }
+  footer {
+    gap: 12px;
+    flex-wrap: wrap;
+  }
+}
+.filters-grid {
+  display: grid;
+  grid-template-columns: repeat(3, minmax(0, 1fr));
+  gap: 12px;
+  padding: 16px 0;
+}
+.filters-grid label {
+  font-size: 11px;
+  color: #68785f;
+}
+.filters-grid input {
+  display: block;
+  width: 100%;
+  margin-top: 6px;
+  padding: 8px;
+  border: 1px solid #d5decd;
+  border-radius: 6px;
+  background: white;
+}
+details summary {
+  font-size: 12px;
+  color: #61795a;
+  cursor: pointer;
+}
+.preview-actions {
+  display: flex;
+  gap: 8px;
+}
+.preview-actions button {
+  font-size: 12px;
+  padding: 8px 12px;
+  border: 1px solid #d3decb;
+  border-radius: 6px;
+  background: #e9efdf;
+  color: #36583c;
+}
+@media (max-width: 760px) {
+  .filters-grid {
+    grid-template-columns: repeat(2, minmax(0, 1fr));
+  }
+}

apps/desktop/tsconfig.json

@@ -0,0 +1,12 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "ESNext",
+    "moduleResolution": "Bundler",
+    "lib": ["ES2022", "DOM"],
+    "strict": true,
+    "noEmit": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}

apps/desktop/vite.config.ts

@@ -0,0 +1,5 @@
+import { defineConfig } from "vite";
+export default defineConfig({
+  server: { port: 1420, strictPort: true },
+  clearScreen: false,
+});