feat(compile-errors): add support for compile error collection and retrieval

- Add Log and LogContainer structs for compile error deserialization
- Implement GetCompileErrors message type and handling
- Add client methods to request compile errors
- Update protocol documentation with new message type details

Author: hackerzhuli

docs/UnityPackageMessagingProtocol.md

@@ -78,6 +78,7 @@ All available message types:
 | `Offline` | 103 | Notifies clients that this package is offline and can not receive messages | Empty string |
 | `IsPlaying` | 104 | Notification of current play mode state | "true" (in play mode) / "false" (in edit mode) |
 | `CompilationStarted` | 105 | Notification that compilation has started | Empty string |
+| `GetCompileErrors` | 106 | Request/response for compile error information | Empty string (request) / JSON serialized LogContainer (response) |
 
 Note:
 - Message value greater than or equal to 100 means it does not exist in the official package but was added in this package.
@@ -129,6 +130,51 @@ Detailed value formats for some of the types:
   - **Compilation Lifecycle**: This message is sent at the beginning of the compilation process, before any assembly compilation starts
   - **Relationship to CompilationFinished**: This message pairs with `CompilationFinished` (Value: 100) to provide complete compilation lifecycle notifications
 
+#### GetCompileErrors (Value: 106)
+- **Format**: 
+  - Request: Empty string
+  - Response: JSON serialized LogContainer object
+- **Description**: Requests the collected compile errors that occurred during Unity's compilation process. Unity collects compile errors within a 1-second window after compilation finishes.
+
+- **C# Structure**:
+
+```csharp
+[Serializable]
+public class LogContainer
+{
+    /// <summary>
+    /// Array of log entries.
+    /// </summary>
+    public Log[] Logs { get; set; }
+}
+
+[Serializable]
+public class Log
+{
+    /// <summary>
+    /// The complete log message as logged by Unity.
+    /// </summary>
+    public string Message;
+    
+    /// <summary>
+    /// The stack trace associated with the log entry, if available.
+    /// </summary>
+    public string StackTrace;
+    
+    /// <summary>
+    /// The timestamp when the log entry was captured as Unix timestamp (milliseconds since epoch).
+    /// </summary>
+    public long Timestamp;
+}
+```
+
+- **Behavior**:
+  - **Collection Window**: Compile errors are collected for 1 second after compilation finishes
+  - **Error Filtering**: Only log messages containing "error CS" are collected
+  - **Automatic Clearing**: Previous compile errors are cleared when compilation starts
+  - **Response Format**: Returns JSON with LogContainer containing array of Log objects
+- **Usage**: Clients can request this to get structured compile error information for IDE integration, error highlighting, and debugging assistance.
+
 #### RetrieveTestList (Value: 23)
 - **Format**: Test mode string ("EditMode" or "PlayMode")
 - **Example**: `"EditMode"`

src/unity_messages.rs

@@ -1,5 +1,22 @@
 use serde::{Deserialize, Serialize};
 
+/// Unity compile error structures for proper deserialization
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct LogContainer {
+    #[serde(rename = "Logs")]
+    pub logs: Vec<Log>,
+}
+
+#[derive(Debug, Clone, Deserialize, Serialize)]
+pub struct Log {
+    #[serde(rename = "Message")]
+    pub message: String,
+    #[serde(rename = "StackTrace")]
+    pub stack_trace: String,
+    #[serde(rename = "Timestamp")]
+    pub timestamp: i64,
+}
+
 /// Unity test result structures for proper deserialization
 #[derive(Debug, Clone, Deserialize, Serialize)]
 pub struct TestResultAdaptorContainer {
@@ -135,6 +152,8 @@ pub enum UnityEvent {
     Offline,
     /// Unity play mode changed
     IsPlaying(bool),
+    /// Compile errors received from Unity
+    CompileErrors(LogContainer),
 }
 
 /// Message types as defined in the Unity Package Messaging Protocol
@@ -169,6 +188,7 @@ pub enum MessageType {
     Offline = 103,
     IsPlaying = 104,
     CompilationStarted = 105,
+    GetCompileErrors = 106,
 }
 
 impl From<i32> for MessageType {
@@ -202,6 +222,7 @@ impl From<i32> for MessageType {
             103 => MessageType::Offline,
             104 => MessageType::IsPlaying,
             105 => MessageType::CompilationStarted,
+            106 => MessageType::GetCompileErrors,
             _ => MessageType::None,
         }
     }

src/unity_messaging_client.rs

@@ -1,13 +1,13 @@
 use crate::unity_messages::{
-    LogLevel, Message, MessageType, TestAdaptorContainer, TestFilter, TestResultAdaptorContainer,
+    LogContainer, LogLevel, Message, MessageType, TestAdaptorContainer, TestFilter, TestResultAdaptorContainer,
     UnityEvent, UnityMessagingError,
 };
 use crate::{debug_log, error_log, info_log};
 use serde::{Deserialize, Serialize};
 use std::net::SocketAddr;
 use std::sync::Arc;
 use std::sync::Mutex;
-use std::time::{Duration, Instant};
+use std::time::{Duration, Instant, SystemTime};
 use tokio::io::AsyncReadExt;
 use tokio::net::{TcpStream, UdpSocket};
 use tokio::sync::broadcast;
@@ -27,6 +27,10 @@ pub struct UnityMessagingClient {
     current_test_run_id: Arc<Mutex<Option<String>>>,
     /// Whether Unity Editor is currently in play mode
     is_in_play_mode: Arc<Mutex<bool>>,
+    /// Timestamp of the last compilation finished event
+    last_compilation_finished: Arc<Mutex<Option<SystemTime>>>,
+    /// Compile errors collected after compilation finishes
+    last_compile_errors: Arc<Mutex<Vec<String>>>,
 }
 
 impl UnityMessagingClient {
@@ -60,6 +64,8 @@ impl UnityMessagingClient {
             is_online: Arc::new(Mutex::new(false)),
             current_test_run_id: Arc::new(Mutex::new(None)),
             is_in_play_mode: Arc::new(Mutex::new(false)),
+            last_compilation_finished: Arc::new(Mutex::new(None)),
+            last_compile_errors: Arc::new(Mutex::new(Vec::new())),
         })
     }
 
@@ -85,6 +91,8 @@ impl UnityMessagingClient {
         let is_online = self.is_online.clone();
         let current_test_run_id = self.current_test_run_id.clone();
         let is_in_play_mode = self.is_in_play_mode.clone();
+        let last_compilation_finished = self.last_compilation_finished.clone();
+        let last_compile_errors = self.last_compile_errors.clone();
 
         // Spawn background task for message listening
         let task = tokio::spawn(async move {
@@ -95,7 +103,7 @@ impl UnityMessagingClient {
                 last_response_time,
                 is_online,
                 current_test_run_id,
-                is_in_play_mode,
+                is_in_play_mode
             )
             .await;
         });
@@ -366,6 +374,16 @@ impl UnityMessagingClient {
             // Compilation messages
             MessageType::CompilationFinished => Some(UnityEvent::CompilationFinished),
             MessageType::CompilationStarted => Some(UnityEvent::CompilationStarted),
+            MessageType::GetCompileErrors => {
+                match serde_json::from_str::<LogContainer>(&message.value) {
+                    Ok(container) => Some(UnityEvent::CompileErrors(container)),
+                    Err(e) => {
+                        error_log!("Failed to deserialize GetCompileErrors data: {}", e);
+                        debug_log!("Raw GetCompileErrors data: {}", message.value);
+                        None
+                    }
+                }
+            }
 
             // Refresh messages
             MessageType::Refresh => Some(UnityEvent::RefreshCompleted(message.value.clone())),
@@ -498,6 +516,19 @@ impl UnityMessagingClient {
         self.send_message(&refresh_message, timeout_seconds).await
     }
 
+    /// Requests compile errors from Unity
+    ///
+    /// This method sends a compile errors request to Unity. The response will be available
+    /// through the event system as a CompileErrors event.
+    ///
+    /// # Returns
+    ///
+    /// Returns `Ok(())` if the request was sent successfully
+    pub async fn get_compile_errors(&self) -> Result<(), UnityMessagingError> {
+        let compile_errors_message = Message::new(MessageType::GetCompileErrors, String::new());
+        self.send_message(&compile_errors_message, None).await
+    }
+
     /// Executes tests based on the specified filter
     ///
     /// This method sends a test execution request to Unity. Test events will be available