Split @ command search into instant + heavy phases so builtin actions (@includeopenfiles) appear immediately while file/folder/git scanning runs in parallel in the background.

Also passes actual search text to group lookups instead of empty string, adds early termination (200 file cap) to prevent full project tree scans, and deduplicates merged results.

Author: AlexanderLuck

src/main/kotlin/ee/carlrobert/codegpt/ui/textarea/PromptTextField.kt

@@ -636,13 +636,24 @@ class PromptTextField(
     }
 
     private suspend fun updateLookupWithSearchResults(searchText: String) {
-        val matchedResults = searchManager.performGlobalSearch(searchText)
+        // Phase 1: Show instant results (builtins, history, personas, MCP) immediately
+        val instantResults = searchManager.performInstantSearch(searchText)
+        if (instantResults.isNotEmpty()) {
+            withContext(Dispatchers.Main) {
+                showGlobalSearchResults(instantResults, searchText)
+            }
+        }
 
-        if (lastSearchResults != matchedResults) {
-            lastSearchResults = matchedResults
+        // Phase 2: Get heavy results (files, folders, git) and merge
+        val heavyResults = searchManager.performHeavySearch(searchText)
+        if (heavyResults.isNotEmpty()) {
+            val allResults = searchManager.mergeResults(instantResults, heavyResults, searchText)
+            lastSearchResults = allResults
             withContext(Dispatchers.Main) {
-                showGlobalSearchResults(matchedResults, searchText)
+                showGlobalSearchResults(allResults, searchText)
             }
+        } else {
+            lastSearchResults = instantResults
         }
     }
 

src/main/kotlin/ee/carlrobert/codegpt/ui/textarea/SearchManager.kt

@@ -11,8 +11,12 @@ import ee.carlrobert.codegpt.ui.textarea.lookup.LookupGroupItem
 import ee.carlrobert.codegpt.ui.textarea.lookup.action.DiagnosticsActionItem
 import ee.carlrobert.codegpt.ui.textarea.lookup.action.ImageActionItem
 import ee.carlrobert.codegpt.ui.textarea.lookup.action.WebActionItem
+import ee.carlrobert.codegpt.ui.textarea.lookup.action.files.IncludeOpenFilesActionItem
+import ee.carlrobert.codegpt.ui.textarea.lookup.action.git.IncludeCurrentChangesActionItem
 import ee.carlrobert.codegpt.ui.textarea.lookup.group.*
 import kotlinx.coroutines.CancellationException
+import kotlinx.coroutines.async
+import kotlinx.coroutines.coroutineScope
 
 data class SearchState(
     val isInSearchContext: Boolean = false,
@@ -63,33 +67,83 @@ class SearchManager(
         ImageActionItem(project, tagManager)
     ).filter { it.enabled }
 
-    suspend fun performGlobalSearch(searchText: String): List<LookupActionItem> {
-        val allGroups =
-            getDefaultGroups().filterNot { it is WebActionItem || it is ImageActionItem }
-        val allResults = mutableListOf<LookupActionItem>()
+    suspend fun performInstantSearch(searchText: String): List<LookupActionItem> {
+        val groups = getDefaultGroups()
+        val results = mutableListOf<LookupActionItem>()
+
+        // Standalone action items that are normally buried inside heavy groups
+        if (groups.any { it is FilesGroupItem }) {
+            results.add(IncludeOpenFilesActionItem())
+        }
+        if (GitFeatureAvailability.isAvailable && groups.any { it is GitGroupItem }) {
+            results.add(IncludeCurrentChangesActionItem())
+        }
 
-        allGroups.forEach { group ->
+        // Lightweight groups (in-memory data only)
+        val lightGroups = groups
+            .filterNot { it is FilesGroupItem || it is FoldersGroupItem || it is GitGroupItem }
+            .filterNot { it is WebActionItem || it is ImageActionItem }
+
+        lightGroups.forEach { group ->
             try {
                 if (group is LookupGroupItem) {
-                    val lookupActionItems =
-                        group.getLookupItems("").filterIsInstance<LookupActionItem>()
-                    allResults.addAll(lookupActionItems)
+                    results.addAll(
+                        group.getLookupItems(searchText).filterIsInstance<LookupActionItem>()
+                    )
                 }
             } catch (e: CancellationException) {
                 throw e
             } catch (e: Exception) {
-                logger.error("Error getting results from ${group::class.simpleName}", e)
+                logger.error("Error getting instant results from ${group::class.simpleName}", e)
             }
         }
 
         if (featureType != FeatureType.INLINE_EDIT && featureType != FeatureType.AGENT) {
             val webAction = WebActionItem(tagManager)
             if (webAction.enabled()) {
-                allResults.add(webAction)
+                results.add(webAction)
             }
         }
 
-        return filterAndSortResults(allResults, searchText)
+        return filterAndSortResults(results, searchText)
+    }
+
+    suspend fun performHeavySearch(searchText: String): List<LookupActionItem> = coroutineScope {
+        val heavyGroups = getDefaultGroups()
+            .filter { it is FilesGroupItem || it is FoldersGroupItem || it is GitGroupItem }
+
+        heavyGroups.map { group ->
+            async {
+                try {
+                    if (group is LookupGroupItem) {
+                        group.getLookupItems(searchText).filterIsInstance<LookupActionItem>()
+                    } else {
+                        emptyList()
+                    }
+                } catch (e: CancellationException) {
+                    throw e
+                } catch (e: Exception) {
+                    logger.error("Error getting results from ${group::class.simpleName}", e)
+                    emptyList()
+                }
+            }
+        }.flatMap { it.await() }
+    }
+
+    fun mergeResults(
+        instantResults: List<LookupActionItem>,
+        heavyResults: List<LookupActionItem>,
+        searchText: String
+    ): List<LookupActionItem> {
+        val seenNames = instantResults.map { it.displayName }.toMutableSet()
+        val dedupedHeavy = heavyResults.filter { seenNames.add(it.displayName) }
+        return filterAndSortResults(instantResults + dedupedHeavy, searchText)
+    }
+
+    suspend fun performGlobalSearch(searchText: String): List<LookupActionItem> {
+        val instant = performInstantSearch(searchText)
+        val heavy = performHeavySearch(searchText)
+        return mergeResults(instant, heavy, searchText)
     }
 
     private fun filterAndSortResults(

src/main/kotlin/ee/carlrobert/codegpt/ui/textarea/lookup/group/FilesGroupItem.kt

@@ -51,16 +51,21 @@ class FilesGroupItem(
             val projectFileIndex = project.service<ProjectFileIndex>()
             val matcher = NameUtil.buildMatcher("*$searchText").build()
             val matchingFiles = mutableListOf<VirtualFile>()
+            val maxFiles = if (searchText.isNotEmpty()) MAX_SEARCH_FILES else Int.MAX_VALUE
 
             projectFileIndex.iterateContent { file ->
-                if (!file.isDirectory &&
-                    settingsService.isVirtualFileVisible(file) &&
-                    !containsTag(file) &&
-                    (searchText.isEmpty() || matcher.matchingDegree(file.name) != Int.MIN_VALUE)
-                ) {
-                    matchingFiles.add(file)
+                if (matchingFiles.size >= maxFiles) {
+                    false
+                } else {
+                    if (!file.isDirectory &&
+                        settingsService.isVirtualFileVisible(file) &&
+                        !containsTag(file) &&
+                        (searchText.isEmpty() || matcher.matchingDegree(file.name) != Int.MIN_VALUE)
+                    ) {
+                        matchingFiles.add(file)
+                    }
+                    true
                 }
-                true
             }
 
             val openFiles = project.service<FileEditorManager>().openFiles
@@ -75,6 +80,10 @@ class FilesGroupItem(
         }
     }
 
+    companion object {
+        private const val MAX_SEARCH_FILES = 200
+    }
+
     private fun containsTag(file: VirtualFile): Boolean {
         return tagManager.containsTag(file)
     }