feat: add completion and devins lang support #471

mpp-core/src/androidMain/kotlin/cc/unitmesh/agent/tool/impl/AndroidCodeParserFactory.kt

@@ -1,15 +1,262 @@
 package cc.unitmesh.agent.tool.impl
 
+import cc.unitmesh.codegraph.model.*
 import cc.unitmesh.codegraph.parser.CodeParser
-import cc.unitmesh.codegraph.parser.ios.IosCodeParser
+import cc.unitmesh.codegraph.parser.Language
 
 /**
- * Android implementation of CodeParser factory
- * Uses the same JVM-based implementation as regular JVM
+ * Android implementation of CodeParser factory.
+ *
+ * Note: Android cannot access jvmMain code directly, so we provide a simplified
+ * regex-based implementation similar to iOS. For full TreeSitter functionality,
+ * consider using server-side parsing.
  */
 actual fun createCodeParser(): CodeParser {
-    // Android uses JVM backend, but IosCodeParser is a fallback
-    // In practice, we should use JvmCodeParser but it's not accessible from androidMain
-    // For now, use the simplified iOS implementation
-    return IosCodeParser()
+    return AndroidCodeParser()
+}
+
+/**
+ * Simplified CodeParser for Android platform.
+ * Uses regex-based parsing to extract basic code structure information.
+ */
+private class AndroidCodeParser : CodeParser {
+
+    override suspend fun parseNodes(
+        sourceCode: String,
+        filePath: String,
+        language: Language
+    ): List<CodeNode> {
+        return when (language) {
+            Language.JAVA, Language.KOTLIN -> parseOOPNodes(sourceCode, filePath, language)
+            Language.JAVASCRIPT, Language.TYPESCRIPT -> parseJSNodes(sourceCode, filePath, language)
+            Language.PYTHON -> parsePythonNodes(sourceCode, filePath, language)
+            else -> emptyList()
+        }
+    }
+
+    override suspend fun parseNodesAndRelationships(
+        sourceCode: String,
+        filePath: String,
+        language: Language
+    ): Pair<List<CodeNode>, List<CodeRelationship>> {
+        val nodes = parseNodes(sourceCode, filePath, language)
+        val relationships = buildRelationships(nodes)
+        return Pair(nodes, relationships)
+    }
+
+    override suspend fun parseCodeGraph(
+        files: Map<String, String>,
+        language: Language
+    ): CodeGraph {
+        val allNodes = mutableListOf<CodeNode>()
+        val allRelationships = mutableListOf<CodeRelationship>()
+
+        for ((filePath, sourceCode) in files) {
+            val (nodes, relationships) = parseNodesAndRelationships(sourceCode, filePath, language)
+            allNodes.addAll(nodes)
+            allRelationships.addAll(relationships)
+        }
+
+        return CodeGraph(
+            nodes = allNodes,
+            relationships = allRelationships,
+            metadata = mapOf(
+                "language" to language.name,
+                "fileCount" to files.size.toString(),
+                "platform" to "Android"
+            )
+        )
+    }
+
+    override suspend fun parseImports(
+        sourceCode: String,
+        filePath: String,
+        language: Language
+    ): List<ImportInfo> {
+        return when (language) {
+            Language.JAVA, Language.KOTLIN -> extractJvmImports(sourceCode, filePath)
+            Language.PYTHON -> extractPythonImports(sourceCode, filePath)
+            Language.JAVASCRIPT, Language.TYPESCRIPT -> extractJsImports(sourceCode, filePath)
+            else -> emptyList()
+        }
+    }
+
+    private fun extractJvmImports(content: String, filePath: String): List<ImportInfo> {
+        val importRegex = Regex("""import\s+(static\s+)?([a-zA-Z_][\w.]*[\w*])""")
+        return importRegex.findAll(content).map { match ->
+            // Calculate actual line number from match position
+            val lineNumber = content.substring(0, match.range.first).count { it == '\n' } + 1
+            ImportInfo(
+                path = match.groupValues[2].removeSuffix(".*"),
+                type = ImportType.MODULE,
+                filePath = filePath,
+                startLine = lineNumber,
+                endLine = lineNumber
+            )
+        }.toList()
+    }
+
+    private fun extractPythonImports(content: String, filePath: String): List<ImportInfo> {
+        val imports = mutableListOf<ImportInfo>()
+
+        val fromImportRegex = Regex("""from\s+([\w.]+)\s+import""")
+        fromImportRegex.findAll(content).forEach { match ->
+            // Calculate actual line number from match position
+            val lineNumber = content.substring(0, match.range.first).count { it == '\n' } + 1
+            imports.add(ImportInfo(
+                path = match.groupValues[1],
+                type = ImportType.MODULE,
+                filePath = filePath,
+                startLine = lineNumber,
+                endLine = lineNumber
+            ))
+        }
+
+        val importRegex = Regex("""^import\s+([\w.]+)""", RegexOption.MULTILINE)
+        importRegex.findAll(content).forEach { match ->
+            // Calculate actual line number from match position
+            val lineNumber = content.substring(0, match.range.first).count { it == '\n' } + 1
+            imports.add(ImportInfo(
+                path = match.groupValues[1],
+                type = ImportType.MODULE,
+                filePath = filePath,
+                startLine = lineNumber,
+                endLine = lineNumber
+            ))
+        }
+
+        return imports
+    }
+
+    private fun extractJsImports(content: String, filePath: String): List<ImportInfo> {
+        val imports = mutableListOf<ImportInfo>()
+
+        val es6ImportRegex = Regex("""import\s+(?:.+\s+from\s+)?['"]([@\w./-]+)['"]""")
+        es6ImportRegex.findAll(content).forEach { match ->
+            // Calculate actual line number from match position
+            val lineNumber = content.substring(0, match.range.first).count { it == '\n' } + 1
+            imports.add(ImportInfo(
+                path = match.groupValues[1],
+                type = ImportType.MODULE,
+                filePath = filePath,
+                startLine = lineNumber,
+                endLine = lineNumber
+            ))
+        }
+
+        return imports
+    }
+
+    private fun parseOOPNodes(
+        sourceCode: String,
+        filePath: String,
+        language: Language
+    ): List<CodeNode> {
+        val nodes = mutableListOf<CodeNode>()
+        val lines = sourceCode.lines()
+        val packageName = extractPackageName(sourceCode)
+
+        val classPattern = Regex("""(class|interface|enum|object)\s+(\w+)""")
+
+        for ((index, line) in lines.withIndex()) {
+            val currentLine = index + 1
+
+            classPattern.find(line)?.let { match ->
+                val type = when (match.groupValues[1]) {
+                    "class", "object" -> CodeElementType.CLASS
+                    "interface" -> CodeElementType.INTERFACE
+                    "enum" -> CodeElementType.ENUM
+                    else -> CodeElementType.CLASS
+                }
+                val name = match.groupValues[2]
+                nodes.add(createCodeNode(name, type, packageName, filePath, currentLine, language))
+            }
+        }
+
+        return nodes
+    }
+
+    private fun parseJSNodes(
+        sourceCode: String,
+        filePath: String,
+        language: Language
+    ): List<CodeNode> {
+        val nodes = mutableListOf<CodeNode>()
+        val lines = sourceCode.lines()
+
+        val classPattern = Regex("""class\s+(\w+)""")
+
+        for ((index, line) in lines.withIndex()) {
+            val currentLine = index + 1
+
+            classPattern.find(line)?.let { match ->
+                val name = match.groupValues[1]
+                nodes.add(createCodeNode(name, CodeElementType.CLASS, "", filePath, currentLine, language))
+            }
+        }
+
+        return nodes
+    }
+
+    private fun parsePythonNodes(
+        sourceCode: String,
+        filePath: String,
+        language: Language
+    ): List<CodeNode> {
+        val nodes = mutableListOf<CodeNode>()
+        val lines = sourceCode.lines()
+
+        val classPattern = Regex("""class\s+(\w+)""")
+
+        for ((index, line) in lines.withIndex()) {
+            val currentLine = index + 1
+
+            classPattern.find(line)?.let { match ->
+                val name = match.groupValues[1]
+                nodes.add(createCodeNode(name, CodeElementType.CLASS, "", filePath, currentLine, language))
+            }
+        }
+
+        return nodes
+    }
+
+    private fun extractPackageName(sourceCode: String): String {
+        val packagePattern = Regex("""package\s+([\w.]+)""")
+        return packagePattern.find(sourceCode)?.groupValues?.get(1) ?: ""
+    }
+
+    private fun createCodeNode(
+        name: String,
+        type: CodeElementType,
+        packageName: String,
+        filePath: String,
+        startLine: Int,
+        language: Language
+    ): CodeNode {
+        val qualifiedName = if (packageName.isNotEmpty()) "$packageName.$name" else name
+        // Use deterministic composite ID to avoid collisions
+        val id = "$filePath:$startLine:$qualifiedName"
+
+        return CodeNode(
+            id = id,
+            type = type,
+            name = name,
+            packageName = packageName,
+            filePath = filePath,
+            startLine = startLine,
+            // Approximate end line: regex parsing cannot determine actual end line,
+            // so we use a reasonable default. For accurate end lines, use TreeSitter-based parsing.
+            endLine = startLine + 10,
+            startColumn = 0,
+            endColumn = 0,
+            qualifiedName = qualifiedName,
+            content = "",
+            metadata = mapOf("language" to language.name, "platform" to "Android")
+        )
+    }
+
+    private fun buildRelationships(nodes: List<CodeNode>): List<CodeRelationship> {
+        // Simplified: no relationships for basic parsing
+        return emptyList()
+    }
 }

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/document/DocumentAgent.kt

@@ -17,19 +17,32 @@ import cc.unitmesh.agent.tool.registry.ToolRegistry
 import cc.unitmesh.agent.tool.schema.AgentToolFormatter
 import cc.unitmesh.agent.tool.shell.DefaultShellExecutor
 import cc.unitmesh.agent.tool.shell.ShellExecutor
+import cc.unitmesh.devins.compiler.template.TemplateCompiler
+import cc.unitmesh.devins.compiler.variable.VariableTable
 import cc.unitmesh.devins.document.DocumentParserService
 import cc.unitmesh.llm.KoogLLMService
 import kotlinx.coroutines.CoroutineScope
 import kotlinx.coroutines.Dispatchers
 import kotlinx.coroutines.SupervisorJob
 import kotlinx.coroutines.launch
+import kotlinx.datetime.Clock
 
 /**
- * Document Task - represents a user query about a document
+ * Document Agent Mode - determines the agent's behavior
+ */
+enum class DocumentAgentMode {
+    DOCUMENT_QUERY,      // Original document query mode using DocQL
+    FEATURE_TREE         // Product feature tree generation mode
+}
+
+/**
+ * Document Task - represents a user query about a document or feature tree request
  */
 data class DocumentTask(
     val query: String,
-    val documentPath: String? = null
+    val documentPath: String? = null,
+    val mode: DocumentAgentMode = DocumentAgentMode.DOCUMENT_QUERY,
+    val language: String = "EN"
 )
 
 /**
@@ -154,11 +167,35 @@ class DocumentAgent(
     private fun buildContext(task: DocumentTask): DocumentContext {
         return DocumentContext(
             query = task.query,
-            documentPath = task.documentPath
+            documentPath = task.documentPath,
+            mode = task.mode,
+            language = task.language
         )
     }
 
     private fun buildSystemPrompt(context: DocumentContext): String {
+        return when (context.mode) {
+            DocumentAgentMode.FEATURE_TREE -> buildFeatureTreePrompt(context)
+            DocumentAgentMode.DOCUMENT_QUERY -> buildDocumentQueryPrompt(context)
+        }
+    }
+
+    private fun buildFeatureTreePrompt(context: DocumentContext): String {
+        val template = when (context.language.uppercase()) {
+            "ZH", "CN" -> ProductFeatureTreeTemplate.ZH
+            else -> ProductFeatureTreeTemplate.EN
+        }
+
+        val variableTable = VariableTable()
+        variableTable.addVariable("projectPath", cc.unitmesh.devins.compiler.variable.VariableType.STRING, actualFileSystem.getProjectPath() ?: ".")
+        variableTable.addVariable("timestamp", cc.unitmesh.devins.compiler.variable.VariableType.STRING, Clock.System.now().toString())
+        variableTable.addVariable("toolList", cc.unitmesh.devins.compiler.variable.VariableType.STRING, AgentToolFormatter.formatToolListForAI(toolRegistry.getAllTools().values.toList()))
+
+        val compiler = TemplateCompiler(variableTable)
+        return compiler.compile(template)
+    }
+
+    private fun buildDocumentQueryPrompt(context: DocumentContext): String {
         return """ You are a Code-First Project Research Assistant.
 Your job is to answer developer questions based on the source code (should be exist can be run by DocQL) and project documentation.
 DocQL Tool supports structured code search using a TreeSitter parser.
@@ -270,6 +307,8 @@ ${AgentToolFormatter.formatToolListForAI(toolRegistry.getAllTools().values.toLis
 
     data class DocumentContext(
         val query: String,
-        val documentPath: String?
+        val documentPath: String?,
+        val mode: DocumentAgentMode = DocumentAgentMode.DOCUMENT_QUERY,
+        val language: String = "EN"
     )
 }