fix: address PR review comments for thread-safety and line number tracking

RendererModels.kt:
- Replace mutable idCounter with random-based ID generation for thread-safety
- Add documentation explaining copy() behavior with default parameters

AndroidCodeParserFactory.kt:
- Fix line number tracking in extractJvmImports, extractPythonImports, extractJsImports
  to use actual line numbers from match positions instead of sequential counters
- Replace hashCode-based ID with deterministic composite ID (filePath:startLine:qualifiedName)
- Add comment explaining the approximate endLine calculation for regex-based parsing

Author: phodal

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

@@ -83,40 +83,45 @@ private class AndroidCodeParser : CodeParser {
 
     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).mapIndexed { index, match ->
+        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 = index,
-                endLine = index
+                startLine = lineNumber,
+                endLine = lineNumber
             )
         }.toList()
     }
 
     private fun extractPythonImports(content: String, filePath: String): List<ImportInfo> {
         val imports = mutableListOf<ImportInfo>()
-        var lineIndex = 0
 
         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 = lineIndex++,
-                endLine = lineIndex
+                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 = lineIndex++,
-                endLine = lineIndex
+                startLine = lineNumber,
+                endLine = lineNumber
             ))
         }
 
@@ -125,16 +130,17 @@ private class AndroidCodeParser : CodeParser {
 
     private fun extractJsImports(content: String, filePath: String): List<ImportInfo> {
         val imports = mutableListOf<ImportInfo>()
-        var lineIndex = 0
 
         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 = lineIndex++,
-                endLine = lineIndex
+                startLine = lineNumber,
+                endLine = lineNumber
             ))
         }
 
@@ -228,14 +234,18 @@ private class AndroidCodeParser : CodeParser {
         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 = qualifiedName.hashCode().toString(),
+            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,

mpp-core/src/commonMain/kotlin/cc/unitmesh/agent/render/RendererModels.kt

@@ -61,6 +61,16 @@ enum class TaskStatus(val displayName: String) {
 /**
  * Base timeline item for chronological rendering.
  * This is the shared base class for timeline items in both ComposeRenderer and JewelRenderer.
+ *
+ * **Important**: When using `copy()` on data class instances, the `id` and `timestamp`
+ * default parameters are NOT re-evaluated. This means copied items will retain the
+ * original `id` and `timestamp` unless explicitly overridden:
+ * ```kotlin
+ * val item1 = TimelineItem.MessageItem(role = MessageRole.USER, content = "Hello")
+ * val item2 = item1.copy(content = "World") // item2.id == item1.id (same ID!)
+ * // To get a new ID:
+ * val item3 = item1.copy(content = "World", id = TimelineItem.generateId())
+ * ```
  */
 sealed class TimelineItem(
     open val timestamp: Long = Platform.getCurrentTimestamp(),
@@ -165,8 +175,17 @@ sealed class TimelineItem(
     ) : TimelineItem(timestamp, id)
 
     companion object {
-        private var idCounter = 0L
-        fun generateId(): String = "${Platform.getCurrentTimestamp()}-${idCounter++}"
+        /**
+         * Thread-safe counter for generating unique IDs.
+         * Uses timestamp + random component to avoid collisions across threads/instances.
+         */
+        private val random = kotlin.random.Random
+
+        /**
+         * Generates a unique ID for timeline items.
+         * Uses timestamp + random component for thread-safety without requiring atomic operations.
+         */
+        fun generateId(): String = "${Platform.getCurrentTimestamp()}-${random.nextInt(0, Int.MAX_VALUE)}"
     }
 }