@mflrevan/ucp 0.4.6 → 0.5.1

package/bridge/com.ucp.bridge/Editor/Controllers/AssetImportSupport.cs

@@ -80,6 +80,47 @@ namespace UCP.Bridge
             return CreateReimportResult(requestedPath, assetPath, true, false, null);
         }
 
+        public static Dictionary<string, object> ReimportRecursive(string requestedPath, bool forceSynchronous = true)
+        {
+            var assetPath = GetPrimaryAssetPath(requestedPath);
+            if (string.IsNullOrEmpty(assetPath))
+                throw new ArgumentException("Missing 'path' parameter");
+            if (!IsProjectAssetPath(assetPath))
+                throw new ArgumentException($"Path is not under Assets/ or Packages/: {requestedPath}");
+
+            if (!AssetDatabase.IsValidFolder(assetPath))
+                return Reimport(requestedPath, forceSynchronous);
+
+            var options = ImportAssetOptions.ForceUpdate;
+            if (forceSynchronous)
+                options |= ImportAssetOptions.ForceSynchronousImport;
+
+            var guidResults = AssetDatabase.FindAssets(string.Empty, new[] { assetPath });
+            var importedPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            foreach (var guid in guidResults)
+            {
+                var childPath = AssetDatabase.GUIDToAssetPath(guid);
+                if (string.IsNullOrEmpty(childPath) || AssetDatabase.IsValidFolder(childPath))
+                    continue;
+
+                AssetDatabase.ImportAsset(childPath, options);
+                importedPaths.Add(childPath);
+                RecordReimport(childPath);
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["requestedPath"] = requestedPath,
+                ["assetPath"] = assetPath,
+                ["recursive"] = true,
+                ["requested"] = importedPaths.Count,
+                ["reimported"] = importedPaths.Count,
+                ["skipped"] = 0,
+                ["paths"] = new List<object>(importedPaths)
+            };
+        }
+
         public static Dictionary<string, object> SaveImporterSettings(string requestedPath, AssetImporter importer, bool noReimport)
         {
             if (importer == null)

package/bridge/com.ucp.bridge/Editor/Controllers/ImporterController.cs

@@ -18,7 +18,10 @@ namespace UCP.Bridge
         {
             var parameters = ParseParameters(paramsJson);
             var requestedPath = RequirePath(parameters);
-            return AssetImportSupport.Reimport(requestedPath);
+            var recursive = TryGetOptionalBool(parameters, "recursive");
+            return recursive
+                ? AssetImportSupport.ReimportRecursive(requestedPath)
+                : AssetImportSupport.Reimport(requestedPath);
         }
 
         private static object HandleRead(string paramsJson)

package/bridge/com.ucp.bridge/Editor/Controllers/LogsController.cs

@@ -45,6 +45,27 @@ namespace UCP.Bridge
             return RecordLog(level, message, stackTrace);
         }
 
+        public static long GetLatestId()
+        {
+            lock (s_historyLock)
+            {
+                return s_history.Count == 0 ? 0 : s_history[s_history.Count - 1].Id;
+            }
+        }
+
+        public static Dictionary<string, object> BuildStatusSummary(long afterId = 0)
+        {
+            lock (s_historyLock)
+            {
+                var ordered = s_history
+                    .Where(entry => entry.Id > afterId)
+                    .OrderBy(entry => entry.Id)
+                    .ToList();
+
+                return BuildStatusResult(ordered, afterId);
+            }
+        }
+
         private static object HandleTail(string paramsJson)
         {
             var query = ParseQuery(paramsJson, includePattern: false);
@@ -77,82 +98,12 @@ namespace UCP.Bridge
 
         private static object HandleStatus(string paramsJson)
         {
-            lock (s_historyLock)
-            {
-                var ordered = s_history.OrderBy(entry => entry.Id).ToList();
-                var byLevel = new Dictionary<string, object>
-                {
-                    ["info"] = ordered.Count(entry => entry.Level == "info"),
-                    ["warning"] = ordered.Count(entry => entry.Level == "warning"),
-                    ["error"] = ordered.Count(entry => entry.Level == "error"),
-                    ["exception"] = ordered.Count(entry => entry.Level == "exception")
-                };
-
-                var grouped = ordered
-                    .GroupBy(entry => $"{entry.Level}|{Fingerprint(entry.Message)}")
-                    .Select(group =>
-                    {
-                        var first = group.First();
-                        var last = group.Last();
-                        return new Dictionary<string, object>
-                        {
-                            ["level"] = first.Level,
-                            ["fingerprint"] = Fingerprint(first.Message),
-                            ["sampleMessage"] = Preview(first.Message, MaxPreviewLength),
-                            ["count"] = group.Count(),
-                            ["firstTimestamp"] = first.Timestamp,
-                            ["lastTimestamp"] = last.Timestamp,
-                            ["latestId"] = last.Id
-                        };
-                    })
-                    .OrderByDescending(entry => Convert.ToInt32(entry["count"]))
-                    .ThenBy(entry => entry["sampleMessage"].ToString())
-                    .ToList();
-
-                var result = new Dictionary<string, object>
-                {
-                    ["total"] = ordered.Count,
-                    ["byLevel"] = byLevel,
-                    ["uniqueCount"] = grouped.Count,
-                    ["topCategories"] = grouped.Take(8).Cast<object>().ToList()
-                };
-
-                if (ordered.Count > 0)
-                {
-                    var first = ordered.First();
-                    var last = ordered.Last();
-                    result["firstTimestamp"] = first.Timestamp;
-                    result["lastTimestamp"] = last.Timestamp;
-                    result["historyWindowSeconds"] = Math.Max(0d, (last.TimestampUtc - first.TimestampUtc).TotalSeconds);
-                    result["latestId"] = last.Id;
-                }
-
-                var playSession = PlayModeController.GetSessionSnapshot();
-                result["play"] = SerializePlaySession(playSession);
-
-                if (playSession.LastEnteredPlayAtUtc.HasValue)
-                {
-                    var sessionEnd = playSession.Playing
-                        ? DateTime.UtcNow
-                        : (playSession.LastExitedPlayAtUtc ?? DateTime.UtcNow);
-                    var sessionLogs = ordered
-                        .Where(entry => entry.TimestampUtc >= playSession.LastEnteredPlayAtUtc.Value
-                            && entry.TimestampUtc <= sessionEnd)
-                        .ToList();
-
-                    result["lastPlayWindow"] = new Dictionary<string, object>
-                    {
-                        ["startedAt"] = playSession.LastEnteredPlayAtUtc.Value.ToString("o"),
-                        ["endedAt"] = sessionEnd.ToString("o"),
-                        ["durationSeconds"] = Math.Max(0d, (sessionEnd - playSession.LastEnteredPlayAtUtc.Value).TotalSeconds),
-                        ["total"] = sessionLogs.Count,
-                        ["warnings"] = sessionLogs.Count(entry => entry.Level == "warning"),
-                        ["errors"] = sessionLogs.Count(entry => entry.Level == "error" || entry.Level == "exception")
-                    };
-                }
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            long afterId = 0;
+            if (p != null && p.TryGetValue("afterId", out var afterIdObj) && afterIdObj != null)
+                afterId = Math.Max(0, Convert.ToInt64(afterIdObj));
 
-                return result;
-            }
+            return BuildStatusSummary(afterId);
         }
 
         private static Dictionary<string, object> RecordLog(string level, string message, string stackTrace)
@@ -257,6 +208,83 @@ namespace UCP.Bridge
             };
         }
 
+        private static Dictionary<string, object> BuildStatusResult(List<LogRecord> ordered, long afterId)
+        {
+            var byLevel = new Dictionary<string, object>
+            {
+                ["info"] = ordered.Count(entry => entry.Level == "info"),
+                ["warning"] = ordered.Count(entry => entry.Level == "warning"),
+                ["error"] = ordered.Count(entry => entry.Level == "error"),
+                ["exception"] = ordered.Count(entry => entry.Level == "exception")
+            };
+
+            var grouped = ordered
+                .GroupBy(entry => $"{entry.Level}|{Fingerprint(entry.Message)}")
+                .Select(group =>
+                {
+                    var first = group.First();
+                    var last = group.Last();
+                    return new Dictionary<string, object>
+                    {
+                        ["level"] = first.Level,
+                        ["fingerprint"] = Fingerprint(first.Message),
+                        ["sampleMessage"] = Preview(first.Message, MaxPreviewLength),
+                        ["count"] = group.Count(),
+                        ["firstTimestamp"] = first.Timestamp,
+                        ["lastTimestamp"] = last.Timestamp,
+                        ["latestId"] = last.Id
+                    };
+                })
+                .OrderByDescending(entry => Convert.ToInt32(entry["count"]))
+                .ThenBy(entry => entry["sampleMessage"].ToString())
+                .ToList();
+
+            var result = new Dictionary<string, object>
+            {
+                ["afterId"] = afterId,
+                ["total"] = ordered.Count,
+                ["byLevel"] = byLevel,
+                ["uniqueCount"] = grouped.Count,
+                ["topCategories"] = grouped.Take(8).Cast<object>().ToList()
+            };
+
+            if (ordered.Count > 0)
+            {
+                var first = ordered.First();
+                var last = ordered.Last();
+                result["firstTimestamp"] = first.Timestamp;
+                result["lastTimestamp"] = last.Timestamp;
+                result["historyWindowSeconds"] = Math.Max(0d, (last.TimestampUtc - first.TimestampUtc).TotalSeconds);
+                result["latestId"] = last.Id;
+            }
+
+            var playSession = PlayModeController.GetSessionSnapshot();
+            result["play"] = SerializePlaySession(playSession);
+
+            if (playSession.LastEnteredPlayAtUtc.HasValue)
+            {
+                var sessionEnd = playSession.Playing
+                    ? DateTime.UtcNow
+                    : (playSession.LastExitedPlayAtUtc ?? DateTime.UtcNow);
+                var sessionLogs = ordered
+                    .Where(entry => entry.TimestampUtc >= playSession.LastEnteredPlayAtUtc.Value
+                        && entry.TimestampUtc <= sessionEnd)
+                    .ToList();
+
+                result["lastPlayWindow"] = new Dictionary<string, object>
+                {
+                    ["startedAt"] = playSession.LastEnteredPlayAtUtc.Value.ToString("o"),
+                    ["endedAt"] = sessionEnd.ToString("o"),
+                    ["durationSeconds"] = Math.Max(0d, (sessionEnd - playSession.LastEnteredPlayAtUtc.Value).TotalSeconds),
+                    ["total"] = sessionLogs.Count,
+                    ["warnings"] = sessionLogs.Count(entry => entry.Level == "warning"),
+                    ["errors"] = sessionLogs.Count(entry => entry.Level == "error" || entry.Level == "exception")
+                };
+            }
+
+            return result;
+        }
+
         private static Dictionary<string, object> SerializeSummary(LogRecord entry)
         {
             return new Dictionary<string, object>

package/bridge/com.ucp.bridge/Editor/Controllers/ReferenceController.cs

@@ -0,0 +1,163 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace UCP.Bridge
+{
+    /// <summary>
+    /// Bridge controller for reference search - used as a fallback when native Rust
+    /// indexing is not available (non-Force-Text projects) or for correctness verification.
+    /// </summary>
+    public static class ReferenceController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("references/find", HandleFind);
+            router.Register("references/serialization-status", HandleSerializationStatus);
+        }
+
+        private static object HandleSerializationStatus(string paramsJson)
+        {
+            var settings = new SerializedObject(
+                AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/EditorSettings.asset")[0]);
+            try
+            {
+                settings.Update();
+                var modeProp = settings.FindProperty("m_SerializationMode");
+                int mode = modeProp != null ? modeProp.intValue : -1;
+
+                return new Dictionary<string, object>
+                {
+                    { "serializationMode", mode },
+                    { "forceText", mode == 2 },
+                    { "visibleMetaFiles", EditorSettings.externalVersionControl == "Visible Meta Files" }
+                };
+            }
+            finally
+            {
+                settings.Dispose();
+            }
+        }
+
+        private static object HandleFind(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null)
+                throw new ArgumentException("Invalid parameters");
+
+            string targetGuid = null;
+            long targetFileId = 0;
+            int maxResults = 100;
+
+            if (p.TryGetValue("guid", out var gObj) && gObj != null)
+                targetGuid = gObj.ToString();
+            if (p.TryGetValue("fileId", out var fObj) && fObj != null)
+                targetFileId = Convert.ToInt64(fObj);
+            if (p.TryGetValue("maxResults", out var mObj) && mObj != null)
+                maxResults = Convert.ToInt32(mObj);
+
+            if (string.IsNullOrEmpty(targetGuid))
+                throw new ArgumentException("Missing 'guid' parameter");
+
+            var targetPath = AssetDatabase.GUIDToAssetPath(targetGuid);
+            var references = new List<object>();
+
+            // Phase 1: Find all assets that depend on the target using AssetDatabase
+            var allAssets = AssetDatabase.GetAllAssetPaths();
+            var dependentPaths = new List<string>();
+
+            foreach (var assetPath in allAssets)
+            {
+                if (!assetPath.StartsWith("Assets/") && !assetPath.StartsWith("Packages/"))
+                    continue;
+
+                var deps = AssetDatabase.GetDependencies(assetPath, false);
+                foreach (var dep in deps)
+                {
+                    if (dep == targetPath)
+                    {
+                        dependentPaths.Add(assetPath);
+                        break;
+                    }
+                }
+            }
+
+            // Phase 2: Walk SerializedObject properties to find exact reference locations
+            foreach (var sourcePath in dependentPaths)
+            {
+                if (references.Count >= maxResults)
+                    break;
+
+                var assets = AssetDatabase.LoadAllAssetsAtPath(sourcePath);
+                foreach (var asset in assets)
+                {
+                    if (asset == null) continue;
+                    if (references.Count >= maxResults) break;
+
+                    var so = new SerializedObject(asset);
+                    try
+                    {
+                        so.Update();
+                        var iterator = so.GetIterator();
+                        bool enterChildren = true;
+
+                        while (iterator.Next(enterChildren))
+                        {
+                            enterChildren = true;
+
+                            if (iterator.propertyType != SerializedPropertyType.ObjectReference)
+                                continue;
+
+                            var refValue = iterator.objectReferenceValue;
+                            if (refValue == null) continue;
+
+                            string refPath = AssetDatabase.GetAssetPath(refValue);
+                            if (string.IsNullOrEmpty(refPath)) continue;
+
+                            string refGuid = AssetDatabase.AssetPathToGUID(refPath);
+                            if (refGuid != targetGuid) continue;
+
+                            // If a specific fileId was requested, check it
+                            if (targetFileId != 0)
+                            {
+                                if (!AssetDatabase.TryGetGUIDAndLocalFileIdentifier(
+                                    refValue, out string _, out long localId))
+                                    continue;
+                                if (localId != targetFileId)
+                                    continue;
+                            }
+
+                            references.Add(new Dictionary<string, object>
+                            {
+                                { "sourcePath", sourcePath },
+                                { "sourceObjectName", asset.name },
+                                { "sourceObjectType", asset.GetType().Name },
+                                { "propertyPath", iterator.propertyPath },
+                                { "targetGuid", targetGuid },
+                                { "targetPath", targetPath },
+                                { "referencedObjectName", refValue.name },
+                                { "referencedObjectType", refValue.GetType().Name }
+                            });
+
+                            if (references.Count >= maxResults)
+                                break;
+                        }
+                    }
+                    finally
+                    {
+                        so.Dispose();
+                    }
+                }
+            }
+
+            return new Dictionary<string, object>
+            {
+                { "targetGuid", targetGuid },
+                { "targetPath", targetPath ?? "" },
+                { "count", references.Count },
+                { "references", references }
+            };
+        }
+    }
+}

package/bridge/com.ucp.bridge/Editor/Controllers/ReferenceController.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1b9c94573b1b483180df2cfe7a7c6396
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/bridge/com.ucp.bridge/Editor/Controllers/SceneController.cs

@@ -44,20 +44,26 @@ namespace UCP.Bridge
                 throw new System.ArgumentException("Missing 'path' parameter");
 
             var path = pathObj.ToString();
+            var additive = GetBoolParam(p, "additive", false);
             var saveDirtyScenes = GetBoolParam(p, "saveDirtyScenes", true);
             var discardUntitled = GetBoolParam(p, "discardUntitled", true);
 
             if (EditorApplication.isPlaying)
             {
-                SceneManager.LoadScene(path);
+                SceneManager.LoadScene(path, additive ? LoadSceneMode.Additive : LoadSceneMode.Single);
             }
             else
             {
                 SaveDirtyScenesIfRequested(saveDirtyScenes, discardUntitled);
-                EditorSceneManager.OpenScene(path, OpenSceneMode.Single);
+                EditorSceneManager.OpenScene(path, additive ? OpenSceneMode.Additive : OpenSceneMode.Single);
             }
 
-            return new { status = "ok", loaded = path };
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["loaded"] = path,
+                ["additive"] = additive
+            };
         }
 
         private static bool GetBoolParam(Dictionary<string, object> parameters, string key, bool defaultValue)

package/bridge/com.ucp.bridge/Editor/Controllers/TestRunnerController.cs

@@ -11,6 +11,7 @@ namespace UCP.Bridge
     {
         private static TestRunnerApi s_api;
         private static TestResultCollector s_collector;
+        private const string ConsoleGuardName = "UCP.Bridge.Tests.ConsoleLogGuard";
 
         public static void Register(CommandRouter router)
         {
@@ -42,7 +43,8 @@ namespace UCP.Bridge
             if (s_collector != null)
                 s_api.UnregisterCallbacks(s_collector);
 
-            s_collector = new TestResultCollector();
+            var logCursor = LogsController.GetLatestId();
+            s_collector = new TestResultCollector(logCursor);
             s_api.RegisterCallbacks(s_collector);
 
             var executionSettings = new ExecutionSettings
@@ -130,11 +132,13 @@ namespace UCP.Bridge
         private class TestResultCollector : ICallbacks
         {
             private readonly List<object> _results = new();
+            private readonly long _logCursor;
             private int _passed, _failed, _skipped;
             private double _startTime;
 
-            public TestResultCollector()
+            public TestResultCollector(long logCursor)
             {
+                _logCursor = logCursor;
                 _startTime = EditorApplication.timeSinceStartup;
             }
 
@@ -147,6 +151,21 @@ namespace UCP.Bridge
                 _failed = 0;
                 _skipped = 0;
                 CollectLeafResults(result);
+                var logSummary = LogsController.BuildStatusSummary(_logCursor);
+                var consoleWarnings = GetLevelCount(logSummary, "warning");
+                var consoleErrors = GetLevelCount(logSummary, "error") + GetLevelCount(logSummary, "exception");
+
+                if (consoleErrors > 0)
+                {
+                    _failed++;
+                    _results.Add(new Dictionary<string, object>
+                    {
+                        ["name"] = ConsoleGuardName,
+                        ["status"] = "failed",
+                        ["duration"] = 0.0,
+                        ["message"] = BuildConsoleGuardMessage(consoleErrors, consoleWarnings, logSummary)
+                    });
+                }
 
                 var duration = EditorApplication.timeSinceStartup - _startTime;
 
@@ -156,13 +175,17 @@ namespace UCP.Bridge
                     ["passed"] = _passed,
                     ["failed"] = _failed,
                     ["skipped"] = _skipped,
-                    ["duration"] = (double)duration
+                    ["duration"] = (double)duration,
+                    ["consoleClean"] = consoleErrors == 0,
+                    ["consoleWarnings"] = consoleWarnings,
+                    ["consoleErrors"] = consoleErrors
                 };
 
                 BridgeServer.BroadcastNotification("tests/result", new Dictionary<string, object>
                 {
                     ["summary"] = summary,
-                    ["tests"] = _results
+                    ["tests"] = _results,
+                    ["logs"] = logSummary
                 });
 
                 if (s_api != null)
@@ -235,6 +258,59 @@ namespace UCP.Bridge
 
                 return result.Name;
             }
+
+            private static int GetLevelCount(Dictionary<string, object> logSummary, string level)
+            {
+                if (!logSummary.TryGetValue("byLevel", out var byLevelObj)
+                    || byLevelObj is not Dictionary<string, object> byLevel
+                    || !byLevel.TryGetValue(level, out var value))
+                {
+                    return 0;
+                }
+
+                return Convert.ToInt32(value);
+            }
+
+            private static string BuildConsoleGuardMessage(
+                int consoleErrors,
+                int consoleWarnings,
+                Dictionary<string, object> logSummary)
+            {
+                var message = $"Unity emitted {consoleErrors} error/exception log(s) during the test run";
+                if (consoleWarnings > 0)
+                    message += $" and {consoleWarnings} warning log(s)";
+
+                if (!logSummary.TryGetValue("topCategories", out var categoriesObj)
+                    || categoriesObj is not List<object> categories
+                    || categories.Count == 0)
+                {
+                    return message + ".";
+                }
+
+                var parts = new List<string>();
+                foreach (var categoryObj in categories)
+                {
+                    if (categoryObj is not Dictionary<string, object> category)
+                        continue;
+
+                    var count = category.TryGetValue("count", out var countObj)
+                        ? Convert.ToInt32(countObj)
+                        : 0;
+                    var sample = category.TryGetValue("sampleMessage", out var sampleObj)
+                        ? sampleObj?.ToString() ?? string.Empty
+                        : string.Empty;
+                    if (count <= 0 || string.IsNullOrEmpty(sample))
+                        continue;
+
+                    parts.Add($"{count}x {sample}");
+                    if (parts.Count >= 3)
+                        break;
+                }
+
+                return parts.Count == 0
+                    ? message + "."
+                    : $"{message}. Top categories: {string.Join(" | ", parts)}";
+            }
         }
     }
 }