feat(devins): improve Java symbol lookup and chat rendering

- Add EDT thread handling for UI updates in chat panel
- Implement comprehensive Java symbol lookup, including packages, classes, methods, and fields
- Enhance SymbolInsCommand to use runReadAction for thread safety
- Update JavaCustomDevInsSymbolProvider to provide more accurate and diverse symbol information

Author: phodal

core/src/main/kotlin/cc/unitmesh/devti/gui/chat/NormalChatCodingPanel.kt

@@ -23,6 +23,7 @@ import cc.unitmesh.devti.sketch.createActionButton
 import cc.unitmesh.devti.sketch.ui.code.HtmlHighlightSketch
 import cc.unitmesh.devti.util.whenDisposed
 import com.intellij.openapi.Disposable
+import com.intellij.openapi.application.runInEdt
 import com.intellij.openapi.progress.ProgressIndicator
 import com.intellij.openapi.progress.ProgressManager
 import com.intellij.openapi.progress.Task
@@ -180,7 +181,10 @@ class NormalChatCodingPanel(private val chatCodingService: ChatCodingService, va
         val displayText = displayPrompt.ifEmpty { message }
 
         val messageView = MessageView(chatCodingService.project, message, role, displayText)
-        myList.add(messageView)
+        runInEdt {
+            myList.add(messageView)
+        }
+
         scrollToBottom()
         progressBar.isIndeterminate = true
         updateUI()

exts/devins-lang/src/main/kotlin/cc/unitmesh/devti/language/compiler/exec/SymbolInsCommand.kt

@@ -4,14 +4,15 @@ import cc.unitmesh.devti.command.InsCommand
 import cc.unitmesh.devti.command.dataprovider.BuiltinCommand
 import cc.unitmesh.devti.language.compiler.error.DEVINS_ERROR
 import cc.unitmesh.devti.provider.devins.DevInsSymbolProvider
+import com.intellij.openapi.application.runReadAction
 import com.intellij.openapi.project.Project
 
 class SymbolInsCommand(val myProject: Project, val prop: String) : InsCommand {
     override val commandName: BuiltinCommand = BuiltinCommand.SYMBOL
 
     override suspend fun execute(): String {
         val result = DevInsSymbolProvider.all().mapNotNull {
-            val found = it.resolveSymbol(myProject, prop)
+            val found = runReadAction { it.resolveSymbol(myProject, prop) }
             if (found.isEmpty()) return@mapNotNull null
             "```${it.language}\n${found.joinToString("\n")}\n```\n"
         }

java/src/main/kotlin/cc/unitmesh/idea/provider/JavaCustomDevInsSymbolProvider.kt

@@ -8,9 +8,7 @@ import com.intellij.ide.highlighter.JavaFileType
 import com.intellij.lang.java.JavaLanguage
 import com.intellij.openapi.application.runReadAction
 import com.intellij.openapi.project.Project
-import com.intellij.psi.PsiElement
-import com.intellij.psi.PsiManager
-import com.intellij.psi.PsiPackageStatement
+import com.intellij.psi.*
 import com.intellij.psi.impl.file.impl.JavaFileManagerImpl
 import com.intellij.psi.search.FileTypeIndex
 import com.intellij.psi.search.GlobalSearchScope
@@ -55,11 +53,29 @@ class JavaCustomDevInsSymbolProvider : DevInsSymbolProvider {
 
         packageStatements.forEach {
             if (it.packageName.startsWith(text)) {
-                val element = LookupElementBuilder.create(it.packageName).withIcon(JavaFileType.INSTANCE.icon)
+                val element = LookupElementBuilder.create(it.packageName)
+                    .withIcon(JavaFileType.INSTANCE.icon)
+                    .withTypeText("package")
                 lookupElements.add(element)
             }
         }
 
+        val psiShortNamesCache = PsiShortNamesCache.getInstance(project)
+        val classNames = psiShortNamesCache.allClassNames
+
+        classNames.forEach { className ->
+            if (className.startsWith(text) || text.isEmpty()) {
+                val psiClasses = psiShortNamesCache.getClassesByName(className, searchScope)
+                psiClasses.forEach { psiClass ->
+                    val qualifiedName = psiClass.qualifiedName ?: return@forEach
+                    val element = LookupElementBuilder.create(qualifiedName)
+                        .withIcon(JavaFileType.INSTANCE.icon)
+                        .withTypeText("class")
+                    lookupElements.add(element)
+                }
+            }
+        }
+
         return lookupElements
     }
 
@@ -68,23 +84,23 @@ class JavaCustomDevInsSymbolProvider : DevInsSymbolProvider {
 
         if (symbol.isEmpty()) return emptyList()
 
-        // className only, like `String` not Dot
         if (symbol.contains(".").not()) {
             val psiClasses = PsiShortNamesCache.getInstance(project).getClassesByName(symbol, scope)
             if (psiClasses.isNotEmpty()) {
-                return psiClasses.map { it.qualifiedName!! }
+                return psiClasses.mapNotNull { it.qualifiedName }
             }
         }
 
-        // for package name only, like `cc.unitmesh`
         JavaFileManagerImpl(project).findPackage(symbol)?.let { pkg ->
-            return pkg.classes.map { it.qualifiedName!! }
+            return pkg.classes.mapNotNull { it.qualifiedName }
         }
 
-        // for single class, with function name, like `cc.unitmesh.idea.provider.JavaCustomDevInsSymbolProvider`
         val clazz = JavaFileManagerImpl(project).findClass(symbol, scope)
         if (clazz != null) {
-            return clazz.methods.map { "${clazz.qualifiedName}#${it.name}" }
+            val classInfo = mutableListOf(clazz.qualifiedName ?: "")
+            classInfo.addAll(clazz.methods.map { "${clazz.qualifiedName ?: ""}#${it.name}" })
+            classInfo.addAll(clazz.fields.map { "${clazz.qualifiedName ?: ""}.${it.name}" })
+            return classInfo
         }
 
         // for lookup for method
@@ -139,6 +155,21 @@ class JavaCustomDevInsSymbolProvider : DevInsSymbolProvider {
             return lookupElementWithMethodName(project, clazzName, scope, methodName)
         }
 
+        // for lookup class field
+        val fieldSplit = symbol.split(".")
+        if (fieldSplit.size >= 2) {
+            val className = fieldSplit.dropLast(1).joinToString(".")
+            val fieldName = fieldSplit.last()
+            
+            val psiClass = JavaFileManagerImpl(project).findClass(className, scope)
+            if (psiClass != null) {
+                val field = psiClass.findFieldByName(fieldName, true)
+                if (field != null) {
+                    return listOf(field)
+                }
+            }
+        }
+
         // may by not our format, like <package>.<class>.<method> split last
         val lastDotIndex = symbol.lastIndexOf(".")
         if (lastDotIndex != -1) {