fix(search): prune recents by frecency and make category icons exhaustive

Review-loop findings:
- Recents were pruned by raw recency but ranked by frecency, so a frequently
  used older block could be evicted while still ranking high. Prune by the same
  frecencyScore used for display; add a regression test
- Make the integration category icon map exhaustive over IntegrationType so a
  newly added category is a compile error instead of a silent generic-icon
  fallback; drive core-block/trigger icons off the category kind
- Factor the shared gate-and-cap rule for the catalog search groups into a
  single cappedCatalog() helper instead of repeating it across five memos

Author: waleedlatif1

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/search-modal/components/search-groups/search-groups.tsx

@@ -45,33 +45,42 @@ import type {
   WorkspaceItem,
 } from '@/app/workspace/[workspaceId]/w/components/sidebar/components/search-modal/utils'
 import { GROUP_HEADING_CLASSNAME } from '@/app/workspace/[workspaceId]/w/components/sidebar/components/search-modal/utils'
+import { IntegrationType } from '@/blocks/types'
 import type {
   SearchBlockItem,
   SearchCategory,
   SearchDocItem,
   SearchToolOperationItem,
 } from '@/stores/modals/search/types'
 
-/** Icon for each browsable category, keyed by {@link SearchCategory.id}. */
-const CATEGORY_ICONS: Record<string, LucideIcon> = {
-  blocks: Blocks,
-  triggers: Zap,
-  ai: Sparkles,
-  analytics: BarChart3,
-  commerce: ShoppingCart,
-  communication: MessageCircle,
-  databases: Database,
-  devops: GitBranch,
-  documents: FileText,
-  email: Mail,
-  hr: Users,
-  marketing: Megaphone,
-  observability: Activity,
-  productivity: ListChecks,
-  sales: TrendingUp,
-  search: SearchIcon,
-  security: Shield,
-  support: LifeBuoy,
+/**
+ * Icon per integration category. Exhaustive over {@link IntegrationType} so a
+ * newly added category is a compile error here rather than a silent fallback.
+ */
+const INTEGRATION_CATEGORY_ICONS: Record<IntegrationType, LucideIcon> = {
+  [IntegrationType.AI]: Sparkles,
+  [IntegrationType.Analytics]: BarChart3,
+  [IntegrationType.Commerce]: ShoppingCart,
+  [IntegrationType.Communication]: MessageCircle,
+  [IntegrationType.Databases]: Database,
+  [IntegrationType.DevOps]: GitBranch,
+  [IntegrationType.Documents]: FileText,
+  [IntegrationType.Email]: Mail,
+  [IntegrationType.HR]: Users,
+  [IntegrationType.Marketing]: Megaphone,
+  [IntegrationType.Observability]: Activity,
+  [IntegrationType.Productivity]: ListChecks,
+  [IntegrationType.Sales]: TrendingUp,
+  [IntegrationType.Search]: SearchIcon,
+  [IntegrationType.Security]: Shield,
+  [IntegrationType.Support]: LifeBuoy,
+}
+
+/** Resolves the icon for a browse category from its kind, then its integration slug. */
+function categoryIcon(category: SearchCategory): LucideIcon {
+  if (category.kind === 'block') return Blocks
+  if (category.kind === 'trigger') return Zap
+  return INTEGRATION_CATEGORY_ICONS[category.id as IntegrationType] ?? Blocks
 }
 
 export const ActionsGroup = memo(function ActionsGroup({
@@ -144,7 +153,7 @@ export const BrowseGroup = memo(function BrowseGroup({
           key={category.id}
           value={`${category.label} category-${category.id}`}
           onSelect={() => onSelect(category)}
-          icon={CATEGORY_ICONS[category.id] ?? Blocks}
+          icon={categoryIcon(category)}
           name={category.label}
           count={category.count}
         />

apps/sim/app/workspace/[workspaceId]/w/components/sidebar/components/search-modal/search-modal.tsx

@@ -99,6 +99,22 @@ function toRecentRow(
   return { id: key, label: item.name, icon: item.icon, bgColor: item.bgColor }
 }
 
+/**
+ * Filters a catalog group for the global search view: empty until the user is
+ * actually searching (`enabled`), then score-sorted and capped so a broad query
+ * never floods the DOM. Single source of the gate-and-cap rule shared by the
+ * blocks, tools, triggers, tool-operations, and docs groups.
+ */
+function cappedCatalog<T>(
+  enabled: boolean,
+  items: T[],
+  toValue: (item: T) => string,
+  search: string
+): T[] {
+  if (!enabled) return []
+  return filterAndSort(items, toValue, search).slice(0, MAX_RESULTS_PER_GROUP)
+}
+
 export type { SearchModalProps } from './utils'
 
 export function SearchModal({
@@ -660,45 +676,36 @@ export function SearchModal({
    */
   const showCatalogResults = isOnWorkflowPage && isSearching && !scope
 
-  const filteredBlocks = useMemo(() => {
-    if (!showCatalogResults) return []
-    return filterAndSort(blocks, (b) => b.searchValue ?? b.name, deferredSearch).slice(
-      0,
-      MAX_RESULTS_PER_GROUP
-    )
-  }, [showCatalogResults, blocks, deferredSearch])
+  const filteredBlocks = useMemo(
+    () => cappedCatalog(showCatalogResults, blocks, (b) => b.searchValue ?? b.name, deferredSearch),
+    [showCatalogResults, blocks, deferredSearch]
+  )
 
-  const filteredTools = useMemo(() => {
-    if (!showCatalogResults) return []
-    return filterAndSort(tools, (t) => t.searchValue ?? t.name, deferredSearch).slice(
-      0,
-      MAX_RESULTS_PER_GROUP
-    )
-  }, [showCatalogResults, tools, deferredSearch])
+  const filteredTools = useMemo(
+    () => cappedCatalog(showCatalogResults, tools, (t) => t.searchValue ?? t.name, deferredSearch),
+    [showCatalogResults, tools, deferredSearch]
+  )
 
-  const filteredTriggers = useMemo(() => {
-    if (!showCatalogResults) return []
-    return filterAndSort(triggers, (t) => `${t.name} ${t.id}`, deferredSearch).slice(
-      0,
-      MAX_RESULTS_PER_GROUP
-    )
-  }, [showCatalogResults, triggers, deferredSearch])
+  const filteredTriggers = useMemo(
+    () => cappedCatalog(showCatalogResults, triggers, (t) => `${t.name} ${t.id}`, deferredSearch),
+    [showCatalogResults, triggers, deferredSearch]
+  )
 
-  const filteredToolOps = useMemo(() => {
-    if (!showCatalogResults) return []
-    return filterAndSort(toolOperations, (op) => op.searchValue, deferredSearch).slice(
-      0,
-      MAX_RESULTS_PER_GROUP
-    )
-  }, [showCatalogResults, toolOperations, deferredSearch])
+  const filteredToolOps = useMemo(
+    () => cappedCatalog(showCatalogResults, toolOperations, (op) => op.searchValue, deferredSearch),
+    [showCatalogResults, toolOperations, deferredSearch]
+  )
 
-  const filteredDocs = useMemo(() => {
-    if (!showCatalogResults) return []
-    return filterAndSort(docs, (d) => `${d.name} docs documentation`, deferredSearch).slice(
-      0,
-      MAX_RESULTS_PER_GROUP
-    )
-  }, [showCatalogResults, docs, deferredSearch])
+  const filteredDocs = useMemo(
+    () =>
+      cappedCatalog(
+        showCatalogResults,
+        docs,
+        (d) => `${d.name} docs documentation`,
+        deferredSearch
+      ),
+    [showCatalogResults, docs, deferredSearch]
+  )
 
   /** Items shown while drilled into a browse category, filtered within scope. */
   const scopedItems = useMemo(() => {

apps/sim/stores/modals/search/recents.test.ts

@@ -75,6 +75,21 @@ describe('useSearchRecentsStore', () => {
     expect(entries['tool:item-59']).toBeDefined()
   })
 
+  it('prunes by frecency, keeping a frequent older item over recent single uses', () => {
+    for (let i = 0; i < 10; i++) {
+      vi.spyOn(Date, 'now').mockReturnValue(i)
+      useSearchRecentsStore.getState().record('tool:popular')
+    }
+    for (let i = 0; i < 50; i++) {
+      vi.spyOn(Date, 'now').mockReturnValue(100 + i)
+      useSearchRecentsStore.getState().record(`tool:once-${i}`)
+    }
+    const { entries } = useSearchRecentsStore.getState()
+    expect(Object.keys(entries)).toHaveLength(50)
+    expect(entries['tool:popular']).toBeDefined()
+    expect(entries['tool:once-0']).toBeUndefined()
+  })
+
   it('clears all entries', () => {
     useSearchRecentsStore.getState().record('block:agent')
     useSearchRecentsStore.getState().clear()

apps/sim/stores/modals/search/recents.ts

@@ -39,21 +39,20 @@ export const useSearchRecentsStore = create<SearchRecentsState>()(
 
       record: (key) =>
         set((state) => {
+          const now = Date.now()
           const previous = state.entries[key]
           const entries: Record<string, RecentEntry> = {
             ...state.entries,
-            [key]: { count: (previous?.count ?? 0) + 1, lastUsedAt: Date.now() },
+            [key]: { count: (previous?.count ?? 0) + 1, lastUsedAt: now },
           }
 
           const keys = Object.keys(entries)
           if (keys.length <= MAX_ENTRIES) return { entries }
 
           const kept = keys
-            .sort((a, b) => entries[b].lastUsedAt - entries[a].lastUsedAt)
+            .sort((a, b) => frecencyScore(entries[b], now) - frecencyScore(entries[a], now))
             .slice(0, MAX_ENTRIES)
-          const pruned: Record<string, RecentEntry> = {}
-          for (const k of kept) pruned[k] = entries[k]
-          return { entries: pruned }
+          return { entries: Object.fromEntries(kept.map((k) => [k, entries[k]])) }
         }),
 
       clear: () => set({ entries: {} }),