feat(pair): improve KotlinWriteTestService and TreeNodeTest

- Improve the `KotlinWriteTestService` class by modifying the `currentClass` variable to use a more concise syntax and handle null values properly.
- Add new test cases to the `TreeNodeTest` class to test the `print()` method for different scenarios, including a single node, a tree with children, and a tree with multiple levels.

Author: phodal

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

@@ -2,10 +2,15 @@ package cc.unitmesh.idea.provider
 
 import cc.unitmesh.devti.pair.arch.ProjectPackageTree
 import cc.unitmesh.devti.provider.architecture.LayeredArchProvider
+import com.intellij.ide.highlighter.JavaFileType
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.projectRoots.JavaSdkType
 import com.intellij.openapi.roots.ProjectRootManager
-import com.intellij.psi.JavaPsiFacade
+import com.intellij.psi.PsiJavaFile
+import com.intellij.psi.PsiManager
+import com.intellij.psi.search.FileTypeIndex
+import com.intellij.psi.search.GlobalSearchScope
+import com.intellij.psi.search.ProjectScope
 
 class JavaLayeredArchProvider : LayeredArchProvider {
     private val layeredArch = ProjectPackageTree()
@@ -16,16 +21,15 @@ class JavaLayeredArchProvider : LayeredArchProvider {
     }
 
     override fun getLayeredArch(project: Project): ProjectPackageTree {
-        val psiFacade = JavaPsiFacade.getInstance(project)
+        val searchScope: GlobalSearchScope = ProjectScope.getContentScope(project)
+        val javaFiles = FileTypeIndex.getFiles(JavaFileType.INSTANCE, searchScope)
+        val psiManager = PsiManager.getInstance(project)
 
-        val projectRootManager = ProjectRootManager.getInstance(project)
-        val contentRoots = projectRootManager.contentRoots
-        for (contentRoot in contentRoots) {
-            // todo implement this
-            val psiPackage = psiFacade.findPackage(contentRoot.url)
-            if (psiPackage != null) {
-                layeredArch.addPackage(psiPackage.qualifiedName)
-            }
+        javaFiles.forEach { javaFile ->
+            val psiFile = psiManager.findFile(javaFile) ?: return@forEach
+            val psiJavaFile = psiFile as? PsiJavaFile ?: return@forEach
+
+            layeredArch.addPackage(psiJavaFile.packageName)
         }
 
         return layeredArch

kotlin/src/main/kotlin/cc/unitmesh/kotlin/provider/KotlinWriteTestService.kt

@@ -90,18 +90,20 @@ class KotlinWriteTestService : WriteTestService() {
 
         project.guessProjectDir()?.refresh(true, true)
 
-        val currentClass = runReadAction {
-            when (element) {
+        val currentClass: String = runReadAction {
+            val classContext = when (element) {
                 is KtClassOrObject -> ClassContextProvider(false).from(element)
                 is KtNamedFunction -> {
                     PsiTreeUtil.getParentOfType(element, KtClassOrObject::class.java)?.let {
-                        return@runReadAction ClassContextProvider(false).from(it)
-                    } ?: return@runReadAction null
+                        ClassContextProvider(false).from(it)
+                    }
                 }
 
                 else -> null
             }
-        }?.format()
+
+            return@runReadAction classContext?.format() ?: ""
+        }
 
         val imports: List<String> = runReadAction {
             (sourceFile as KtFile).importList?.imports?.map { it.text } ?: emptyList()

src/233/main/resources/META-INF/autodev-core.xml

@@ -50,13 +50,13 @@
                     icon="cc.unitmesh.devti.AutoDevIcons.AI_COPILOT"
                     factoryClass="cc.unitmesh.devti.gui.AutoDevToolWindowFactory"/>
 
-        <toolWindow id="AutoDev Pair"
-                    doNotActivateOnStart="true"
-                    anchor="left"
-                    secondary="true"
-                    canCloseContents="false"
-                    icon="cc.unitmesh.devti.AutoDevIcons.AI_PAIR"
-                    factoryClass="cc.unitmesh.devti.gui.AutoDevPairToolWindowFactory"/>
+<!--        <toolWindow id="AutoDev Pair"-->
+<!--                    doNotActivateOnStart="true"-->
+<!--                    anchor="left"-->
+<!--                    secondary="true"-->
+<!--                    canCloseContents="false"-->
+<!--                    icon="cc.unitmesh.devti.AutoDevIcons.AI_PAIR"-->
+<!--                    factoryClass="cc.unitmesh.devti.gui.AutoDevPairToolWindowFactory"/>-->
 
         <notificationGroup id="AI notification group" displayType="STICKY_BALLOON" bundle="messages.AutoDevBundle"
                            key="name"/>

src/main/kotlin/cc/unitmesh/devti/gui/AutoDevPairToolWindowFactory.kt

@@ -1,12 +1,17 @@
 package cc.unitmesh.devti.gui
 
+import cc.unitmesh.devti.fullWidthCell
+import cc.unitmesh.devti.gui.chat.ChatRole
 import cc.unitmesh.devti.provider.architecture.LayeredArchProvider
+import cc.unitmesh.devti.util.parser.Code
 import com.intellij.openapi.Disposable
+import com.intellij.openapi.fileTypes.PlainTextLanguage
 import com.intellij.openapi.project.Project
 import com.intellij.openapi.ui.NullableComponent
 import com.intellij.openapi.ui.SimpleToolWindowPanel
 import com.intellij.openapi.wm.ToolWindow
 import com.intellij.openapi.wm.ToolWindowFactory
+import com.intellij.temporary.gui.block.*
 import com.intellij.ui.dsl.builder.panel
 
 class AutoDevPairToolWindowFactory : ToolWindowFactory {
@@ -27,11 +32,15 @@ class AutoDevPairToolWindow(val project: Project, val disposable: Disposable) :
         val layeredArch = LayeredArchProvider.find(project)?.getLayeredArch(project)
         val panel = panel {
             row {
-                label("Hello World")
+                label("Layered Architecture")
             }
             row {
-                // show a tree in a table
-                label(layeredArch.toString())
+                val text = layeredArch?.print() ?: "No Layered Arch"
+                val block = CodeBlock(SimpleMessage(text, text, ChatRole.User))
+                block.code = Code(PlainTextLanguage.INSTANCE, text, true)
+
+                val codeBlockView = CodeBlockView(block, project, disposable)
+                fullWidthCell(codeBlockView.getComponent())
             }
         }
 

src/main/kotlin/cc/unitmesh/devti/pair/arch/TreeNode.kt

@@ -1,17 +1,29 @@
 package cc.unitmesh.devti.pair.arch
 
+/**
+ * Represents a node in a tree structure.
+ *
+ * @property name the name of the node
+ * @property children the list of child nodes
+ */
 class TreeNode(val name: String, val children: MutableList<TreeNode> = mutableListOf()) {
     fun addChild(child: TreeNode) {
         children.add(child)
     }
 
-    fun print(): String {
+    fun print(indent: String = "", isLast: Boolean = false): String {
         val sb = StringBuilder()
+        sb.append(indent)
+        sb.append(if (isLast) "└── " else "├── ")
         sb.append(name)
         sb.append("\n")
-        for (child in children) {
-            sb.append(child.print())
+
+        val childIndent = "$indent${if (isLast) "    " else "│   "}"
+        for ((index, child) in children.withIndex()) {
+            val childIsLast = index == children.size - 1
+            sb.append(child.print(childIndent, childIsLast))
         }
+
         return sb.toString()
     }
-}
+}

src/test/kotlin/cc/unitmesh/devti/pair/arch/TreeNodeTest.kt

@@ -0,0 +1,75 @@
+package cc.unitmesh.devti.pair.arch;
+
+import org.junit.Assert.assertEquals
+import org.junit.Test
+
+class TreeNodeTest {
+
+    @Test
+    fun shouldPrintSingleNode() {
+        // given
+        val node = TreeNode("A")
+
+        // when
+        val result = node.print()
+
+        // then
+        assertEquals("├── A\n", result)
+    }
+
+    @Test
+    fun shouldPrintTreeWithChildren() {
+        // given
+        val nodeA = TreeNode("A")
+        val nodeB = TreeNode("B")
+        val nodeC = TreeNode("C")
+        val nodeD = TreeNode("D")
+        nodeA.addChild(nodeB)
+        nodeA.addChild(nodeC)
+        nodeC.addChild(nodeD)
+
+        // when
+        val result = nodeA.print()
+
+        // then
+        val expected = """
+            ├── A
+            │   ├── B
+            │   └── C
+            │       └── D
+
+            """.trimIndent()
+        assertEquals(expected, result)
+    }
+
+    @Test
+    fun shouldPrintTreeWithMultipleLevels() {
+        // given
+        val nodeA = TreeNode("A")
+        val nodeB = TreeNode("B")
+        val nodeC = TreeNode("C")
+        val nodeD = TreeNode("D")
+        val nodeE = TreeNode("E")
+        val nodeF = TreeNode("F")
+        nodeA.addChild(nodeB)
+        nodeA.addChild(nodeC)
+        nodeB.addChild(nodeD)
+        nodeB.addChild(nodeE)
+        nodeC.addChild(nodeF)
+
+        // when
+        val result = nodeA.print()
+
+        // then
+        val expected = """
+        ├── A
+        │   ├── B
+        │   │   ├── D
+        │   │   └── E
+        │   └── C
+        │       └── F
+
+        """.trimIndent()
+        assertEquals(expected, result)
+    }
+}