feat(search): add node label search and source filtering

Author: w-winter

CHANGELOG.md

@@ -6,6 +6,14 @@ All notable changes to Pi Session Manager will be documented in this file.
 
 ### Added
 
+- **Pi tree node-label search and source filtering** — labels are now first-class searchable node metadata in global full-text search and the in-session tree
+  - Added Pi-specific raw label parsing with latest-wins / empty-label-clears semantics
+  - Indexed resolved labels as `source_type = "label"` hits tied to target nodes
+  - Added global `sourceFilter` modes: `all`, `labels_only`, `content_only`
+  - Added browse-all-labels behavior for `labels_only + empty query`
+  - Added backend/runtime `get_session_labels` lookup for chunked session trees
+  - Added label-aware session-tree display, local search, labeled-only filtering, and target-node navigation
+
 - **Pi Live session integration** — real-time session sync with pi agent
   - Unified TypeScript type definitions for live sessions
   - Live session indicator in sidebar and dashboard

README.md

@@ -20,7 +20,7 @@
 ## Highlights
 
 - Session browser with list/project/kanban views, favorites, tags, rename, delete, and export.
-- Full-text search via SQLite FTS + Tantivy-backed indexing/search flows.
+- Full-text search via SQLite FTS + Tantivy-backed indexing/search flows, including tree node label search and node content vs. label source filtering.
 - In-session message search with inline highlights, current-match navigation, and keyboard-friendly close/reset behavior. `Cmd/Ctrl + F` behavior is configurable (search vs. sidebar toggle).
 - Built-in terminal (PTY) and one-click resume of Pi sessions.
 - **External Sessions** — scan and browse sessions from other coding agents (Claude, OpenCode, etc.) with unified settings UI for scan control and default resume targets.

package.json

@@ -51,6 +51,7 @@
   },
   "devDependencies": {
     "@tauri-apps/cli": "^2.1.0",
+    "@testing-library/react": "^16.3.2",
     "@types/highlight.js": "^10.1.0",
     "@types/node": "^25.1.0",
     "@types/react": "^18.3.12",
@@ -60,12 +61,14 @@
     "autoprefixer": "^10.4.23",
     "code-inspector-plugin": "^1.4.2",
     "husky": "^9.1.7",
+    "jsdom": "^29.0.2",
     "less": "^4.6.4",
     "postcss": "^8.5.6",
     "tailwindcss": "^3.4.0",
     "tau-mirror": "^1.0.7",
     "typescript": "^5.6.3",
     "vite": "^5.4.11",
-    "vite-plugin-pwa": "^1.2.0"
+    "vite-plugin-pwa": "^1.2.0",
+    "vitest": "^4.1.4"
   }
 }

src-tauri-cli/src/main.rs

@@ -449,7 +449,7 @@ async fn dispatch_command(
                 .unwrap_or(fallback)))
         }
         "get_available_shells" => Ok(serde_json::json!(terminal::scan_shells())),
-        _ => pi_session_manager::dispatch::dispatch(command, payload).await,
+        _ => pi_session_manager::dispatch::dispatch_without_app_state(command, payload).await,
     }
 }
 

src-tauri/examples/sql_index_bench.rs

@@ -333,6 +333,7 @@ async fn run_once(
             args.page_size,
             case.match_mode.map(str::to_string),
             None,
+            None,
         )
         .await
         .map_err(boxed_error)?;

src-tauri/src/api_readonly.rs

@@ -97,6 +97,10 @@ pub struct FullTextSearchRequest {
     pub page_size: Option<usize>,
     #[serde(default)]
     pub match_mode: Option<String>,
+    #[serde(default)]
+    pub sort_order: Option<String>,
+    #[serde(default)]
+    pub source_filter: Option<String>,
 }
 
 #[derive(Debug, Clone, Deserialize)]
@@ -310,35 +314,86 @@ where
     D: Fn(&'static str, Value) -> Fut,
     Fut: Future<Output = Result<Value, String>>,
 {
-    if req.query.trim().is_empty() {
+    let source_filter = req.source_filter.clone();
+    let allows_empty_query = matches!(source_filter.as_deref(), Some("labels_only"));
+    if req.query.trim().is_empty() && !allows_empty_query {
         return Err(ApiReadonlyError::bad_request("query is required"));
     }
 
     let from = parse_time_opt(&req.from)?;
     let to = parse_time_opt(&req.to)?;
-    let effective_glob = effective_glob(req.glob_pattern.clone(), req.project.as_deref());
-    let payload = serde_json::json!({
-        "query": req.query,
-        "role_filter": req.role_filter.unwrap_or_else(|| "all".to_string()),
-        "glob_pattern": effective_glob,
-        "page": req.page.unwrap_or(0),
-        "page_size": req.page_size.unwrap_or(20),
-        "match_mode": req.match_mode,
-    });
+    let effective_glob = effective_glob(req.glob_pattern.clone(), None);
+    let requested_page = req.page.unwrap_or(0);
+    let requested_page_size = req.page_size.unwrap_or(20);
+    let role_filter = req.role_filter.unwrap_or_else(|| "all".to_string());
+    let project_path = req.project.clone();
+    let needs_post_filter = from.is_some() || to.is_some();
+
+    let build_payload = |page: usize, page_size: usize| {
+        serde_json::json!({
+            "query": req.query,
+            "role_filter": role_filter,
+            "glob_pattern": effective_glob,
+            "project_path": project_path,
+            "page": page,
+            "page_size": page_size,
+            "match_mode": req.match_mode,
+            "sort_order": req.sort_order,
+            "source_filter": source_filter,
+        })
+    };
 
-    let data = dispatch("full_text_search", payload)
-        .await
-        .map_err(ApiReadonlyError::bad_request)?;
-    let mut response: FullTextSearchResponse = serde_json::from_value(data)
-        .map_err(|e| ApiReadonlyError::internal(format!("Invalid search response: {e}")))?;
+    if needs_post_filter && normalize_filtered {
+        let mut backend_page = 0usize;
+        let fetch_page_size = requested_page_size.max(100);
+        let mut filtered_hits = Vec::new();
+
+        loop {
+            let data = dispatch(
+                "full_text_search",
+                build_payload(backend_page, fetch_page_size),
+            )
+            .await
+            .map_err(ApiReadonlyError::bad_request)?;
+            let response: FullTextSearchResponse = serde_json::from_value(data)
+                .map_err(|e| ApiReadonlyError::internal(format!("Invalid search response: {e}")))?;
+
+            filtered_hits.extend(
+                response
+                    .hits
+                    .into_iter()
+                    .filter(|hit| hit_matches_scope(hit, None, from, to)),
+            );
+
+            if !response.has_more {
+                break;
+            }
+            backend_page += 1;
+        }
 
-    response
-        .hits
-        .retain(|hit| hit_matches_scope(hit, req.project.as_deref(), from, to));
-    response.total_hits = response.hits.len();
-    if normalize_filtered {
-        response.has_more = false;
+        let total_hits = filtered_hits.len();
+        let start = requested_page.saturating_mul(requested_page_size);
+        let hits = filtered_hits
+            .into_iter()
+            .skip(start)
+            .take(requested_page_size)
+            .collect::<Vec<_>>();
+        return Ok(FullTextSearchResponse {
+            has_more: start.saturating_add(hits.len()) < total_hits,
+            total_hits,
+            hits,
+        });
     }
+
+    let data = dispatch(
+        "full_text_search",
+        build_payload(requested_page, requested_page_size),
+    )
+    .await
+    .map_err(ApiReadonlyError::bad_request)?;
+    let response: FullTextSearchResponse = serde_json::from_value(data)
+        .map_err(|e| ApiReadonlyError::internal(format!("Invalid search response: {e}")))?;
+
     Ok(response)
 }
 
@@ -363,6 +418,8 @@ where
             page: Some(0),
             page_size: Some(top_k),
             match_mode: Some("any".to_string()),
+            sort_order: None,
+            source_filter: None,
         },
         true,
     )