fix(code-tab): persist tree search query across row clicks

srid · srid · commit f989baac37b0 · 2026-04-24T17:49:16.000-04:00
Pierre's FileTree closes the search session on input blur. Their
`searchBlurBehavior: 'retain'` only protects the *initial mount* query
(per the implementation comment in FileTreeView.tsx), so as soon as the
user types and then clicks a result, the filter vanishes — terrible for
the tree+viewer pattern where you want to scan multiple matches.

Workaround: track the live query via `onSearchChange` and re-open the
search inside `onSelectionChange` with a short window-based heuristic.
Escape (close not followed by a selection) still closes; row click
(close immediately followed by a selection) re-opens with the saved
query.
diff --git a/packages/client/src/ui/PierreFileTree.tsx b/packages/client/src/ui/PierreFileTree.tsx
@@ -57,6 +57,16 @@ const PierreFileTree: Component<PierreFileTreeProps> = (props) => {
   // set is a reliable file-vs-folder discriminator.
   const fileSet = createMemo(() => new Set(props.paths));
 
+  // Pierre clears the search query whenever the input blurs (clicking a row
+  // steals focus → query gone). Their `searchBlurBehavior: 'retain'` only
+  // protects the *initial* mount query, not user-typed queries. We work
+  // around it: track the live query, and when a row click closes the search,
+  // re-open it with the saved query. Escape / explicit clear still close
+  // because they aren't followed by a selection.
+  let liveQuery = "";
+  let pendingRestore: number | undefined;
+  const RESTORE_WINDOW_MS = 120;
+
   onMount(() => {
     tree = new FileTree({
       paths: props.paths,
@@ -65,11 +75,38 @@ const PierreFileTree: Component<PierreFileTreeProps> = (props) => {
       search: props.search ?? true,
       gitStatus: props.gitStatus,
       initialSelectedPaths: props.selectedPath ? [props.selectedPath] : [],
+      onSearchChange: (value) => {
+        if (value !== null) {
+          liveQuery = value;
+          if (pendingRestore !== undefined) {
+            clearTimeout(pendingRestore);
+            pendingRestore = undefined;
+          }
+          return;
+        }
+        if (!liveQuery) return;
+        // Session closed; wait briefly to see if a selection follows. If so,
+        // we treat the close as a side-effect of the row click and restore.
+        // If no selection arrives in the window, the user pressed Escape (or
+        // similar) and we let the close stand.
+        pendingRestore = window.setTimeout(() => {
+          pendingRestore = undefined;
+          liveQuery = "";
+        }, RESTORE_WINDOW_MS);
+      },
       onSelectionChange: (paths) => {
         // Pierre fires with all selected paths; we model single-select.
         const p = paths[0] ?? null;
         if (p !== null && !fileSet().has(p)) return; // ignore directories
         props.onSelect?.(p);
+        if (pendingRestore !== undefined) {
+          clearTimeout(pendingRestore);
+          pendingRestore = undefined;
+          if (liveQuery) {
+            const q = liveQuery;
+            queueMicrotask(() => tree?.openSearch(q));
+          }
+        }
       },
     });
     tree.render({ containerWrapper: container });
@@ -91,7 +128,10 @@ const PierreFileTree: Component<PierreFileTreeProps> = (props) => {
     ),
   );
 
-  onCleanup(() => tree?.cleanUp());
+  onCleanup(() => {
+    if (pendingRestore !== undefined) clearTimeout(pendingRestore);
+    tree?.cleanUp();
+  });
 
   return (
     <div
