Method search

src/renderer/features/mentions/search/engine.ts:50–108

* Search across all registered providers

(
    trigger: string,
    query: string,
    baseContext: Omit<MentionSearchContext, "query" | "signal" | "limit">,
    options: MentionSearchOptions = {}
  )

   * Search across all registered providers
   */
  async search(
    trigger: string,
    query: string,
    baseContext: Omit<MentionSearchContext, "query" | "signal" | "limit">,
    options: MentionSearchOptions = {}
  ): Promise<AggregatedSearchResult> {
    const startTime = performance.now()
    const opts = { ...DEFAULT_OPTIONS, ...options }

    // Cancel any pending search for this trigger
    const searchKey = `${trigger}:${baseContext.projectPath ?? "global"}`
    const existingController = this.pendingSearches.get(searchKey)
    if (existingController) {
      existingController.abort()
    }

    // Create new abort controller
    const controller = new AbortController()
    this.pendingSearches.set(searchKey, controller)

    try {
      // Get applicable providers
      let providers = mentionRegistry.getByTrigger(trigger)

      // Filter by provider IDs if specified
      if (opts.providerIds && opts.providerIds.length > 0) {
        const providerIdSet = new Set(opts.providerIds)
        providers = providers.filter((p) => providerIdSet.has(p.id))
      }

      // Filter by availability
      providers = providers.filter(
        (p) => p.isAvailable?.({ projectPath: baseContext.projectPath }) ?? true
      )

      if (providers.length === 0) {
        return this.createEmptyResult(startTime)
      }

      // Build search context
      const context: MentionSearchContext = {
        ...baseContext,
        query,
        signal: controller.signal,
        limit: 50,
      }

      // Search all providers
      const results = opts.parallel
        ? await this.searchParallel(providers, context, opts)
        : await this.searchSequential(providers, context, opts)

      // Aggregate results
      return this.aggregateResults(results, query, startTime)
    } finally {
      // Cleanup
      this.pendingSearches.delete(searchKey)
    }