@mflrevan/ucp 0.5.0 → 0.5.2

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

@@ -0,0 +1,151 @@
+using System;
+using System.Collections.Generic;
+using System.Reflection;
+using UnityEditor;
+using UnityEngine;
+
+namespace UCP.Bridge
+{
+    public static class ShaderController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("shader/errors", HandleErrors);
+        }
+
+        private static object HandleErrors(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var errorsOnly = p != null && p.TryGetValue("errorsOnly", out var errorsOnlyObj) && errorsOnlyObj != null && Convert.ToBoolean(errorsOnlyObj);
+            var filter = p != null && p.TryGetValue("filter", out var filterObj) && filterObj != null ? filterObj.ToString() : null;
+
+            AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+
+            var diagnostics = new List<object>();
+            var scanned = 0;
+            foreach (var guid in AssetDatabase.FindAssets("t:Shader"))
+            {
+                var path = AssetDatabase.GUIDToAssetPath(guid);
+                var shader = AssetDatabase.LoadAssetAtPath<Shader>(path);
+                if (shader == null)
+                    continue;
+                if (!MatchesFilter(shader.name, path, filter))
+                    continue;
+
+                scanned++;
+                foreach (var diagnostic in ReadShaderDiagnostics(shader, path, errorsOnly))
+                    diagnostics.Add(diagnostic);
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["capability"] = FindShaderMessageMethod() != null ? "shader-messages" : "fallback",
+                ["scanned"] = scanned,
+                ["count"] = diagnostics.Count,
+                ["diagnostics"] = diagnostics
+            };
+        }
+
+        private static IEnumerable<object> ReadShaderDiagnostics(Shader shader, string path, bool errorsOnly)
+        {
+            var method = FindShaderMessageMethod();
+            if (method == null)
+                yield break;
+
+            var messages = method.Invoke(null, new object[] { shader }) as Array;
+            if (messages == null)
+                yield break;
+
+            foreach (var message in messages)
+            {
+                var isWarning = ReadBoolMember(message, "warning", "isWarning");
+                if (errorsOnly && isWarning)
+                    continue;
+
+                yield return new Dictionary<string, object>
+                {
+                    ["shader"] = shader.name,
+                    ["path"] = path,
+                    ["severity"] = isWarning ? "warning" : "error",
+                    ["message"] = ReadStringMember(message, "message", "messageDetails"),
+                    ["line"] = ReadIntMember(message, "line"),
+                    ["platform"] = ReadStringMember(message, "platform"),
+                    ["file"] = ReadStringMember(message, "file")
+                };
+            }
+        }
+
+        private static MethodInfo FindShaderMessageMethod()
+        {
+            var shaderUtil = typeof(Editor).Assembly.GetType("UnityEditor.ShaderUtil");
+            return FindShaderMethod(shaderUtil, "GetShaderMessages")
+                ?? FindShaderMethod(shaderUtil, "GetShaderErrors");
+        }
+
+        private static MethodInfo FindShaderMethod(Type shaderUtil, string name)
+        {
+            if (shaderUtil == null)
+                return null;
+
+            foreach (var method in shaderUtil.GetMethods(BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic))
+            {
+                if (method.Name != name)
+                    continue;
+                var parameters = method.GetParameters();
+                if (parameters.Length == 1 && parameters[0].ParameterType == typeof(Shader))
+                    return method;
+            }
+
+            return null;
+        }
+
+        private static bool MatchesFilter(string shaderName, string path, string filter)
+        {
+            if (string.IsNullOrEmpty(filter))
+                return true;
+            return shaderName.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0
+                || path.IndexOf(filter, StringComparison.OrdinalIgnoreCase) >= 0;
+        }
+
+        private static string ReadStringMember(object target, params string[] names)
+        {
+            foreach (var name in names)
+            {
+                var value = ReadMember(target, name);
+                if (value != null)
+                    return value.ToString();
+            }
+
+            return string.Empty;
+        }
+
+        private static int ReadIntMember(object target, string name)
+        {
+            var value = ReadMember(target, name);
+            return value != null ? Convert.ToInt32(value) : 0;
+        }
+
+        private static bool ReadBoolMember(object target, params string[] names)
+        {
+            foreach (var name in names)
+            {
+                var value = ReadMember(target, name);
+                if (value != null)
+                    return Convert.ToBoolean(value);
+            }
+
+            return false;
+        }
+
+        private static object ReadMember(object target, string name)
+        {
+            var type = target.GetType();
+            var field = type.GetField(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+            if (field != null)
+                return field.GetValue(target);
+            var property = type.GetProperty(name, BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic);
+            return property?.GetValue(target);
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 4cfbd1702c2741b48996b2de530bcb96

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

@@ -1,5 +1,6 @@
 using System;
 using System.Collections.Generic;
+using System.Linq;
 using UnityEngine;
 using UnityEngine.SceneManagement;
 
@@ -10,6 +11,8 @@ namespace UCP.Bridge
         public static void Register(CommandRouter router)
         {
             router.Register("snapshot", HandleSnapshot);
+            router.Register("scene/query", HandleSceneQuery);
+            router.Register("object/get-children", HandleGetChildren);
             router.Register("objects/list", HandleListObjects);
             router.Register("objects/components", HandleGetComponents);
             router.Register("objects/transform", HandleGetTransform);
@@ -120,20 +123,84 @@ namespace UCP.Bridge
             return new Dictionary<string, object> { ["objects"] = objects };
         }
 
-        private static void ListObjectsRecursive(GameObject go, List<object> list, int depth, int maxDepth)
+        private static object HandleSceneQuery(string paramsJson)
         {
-            list.Add(new Dictionary<string, object>
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("query", out var queryObj) || queryObj == null)
+                throw new ArgumentException("Missing 'query' parameter");
+
+            var query = ParseSceneQuery(queryObj.ToString());
+            var fields = ParseFields(p.TryGetValue("fields", out var fieldsObj) ? fieldsObj?.ToString() : null);
+            var maxDepth = 32;
+            if (p.TryGetValue("depth", out var depthObj) && depthObj != null)
+                maxDepth = Math.Max(0, Convert.ToInt32(depthObj));
+
+            var scene = SceneManager.GetActiveScene();
+            var results = new List<object>();
+            foreach (var root in scene.GetRootGameObjects())
+                QueryHierarchy(root, query, fields, results, 0, maxDepth);
+
+            return new Dictionary<string, object>
             {
-                ["instanceId"] = go.GetInstanceID(),
+                ["scene"] = scene.path,
+                ["sceneName"] = scene.name,
+                ["query"] = query.Raw,
+                ["count"] = results.Count,
+                ["objects"] = results
+            };
+        }
+
+        private static object HandleGetChildren(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("instanceId", out var idObj))
+                throw new ArgumentException("Missing 'instanceId' parameter");
+
+            int instanceId = Convert.ToInt32(idObj);
+            int maxDepth = 1;
+            if (p.TryGetValue("depth", out var depthObj))
+                maxDepth = Math.Max(1, Convert.ToInt32(depthObj));
+
+            var go = FindByInstanceId(instanceId);
+            if (go == null)
+                throw new Exception($"GameObject not found: {instanceId}");
+
+            var children = new List<object>();
+            int objectCount = 0;
+            int componentCount = 0;
+
+            for (int i = 0; i < go.transform.childCount; i++)
+            {
+                children.Add(SerializeGameObjectTree(
+                    go.transform.GetChild(i).gameObject,
+                    1,
+                    maxDepth,
+                    ref objectCount,
+                    ref componentCount));
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["instanceId"] = instanceId,
                 ["name"] = go.name,
                 ["active"] = go.activeSelf,
                 ["tag"] = go.tag,
                 ["layer"] = go.layer,
                 ["layerName"] = LayerMask.LayerToName(go.layer),
                 ["childCount"] = go.transform.childCount,
-                ["components"] = GetComponentTypes(go),
-                ["depth"] = depth
-            });
+                ["requestedDepth"] = maxDepth,
+                ["children"] = children,
+                ["stats"] = new Dictionary<string, object>
+                {
+                    ["objectCount"] = objectCount,
+                    ["componentCount"] = componentCount
+                }
+            };
+        }
+
+        private static void ListObjectsRecursive(GameObject go, List<object> list, int depth, int maxDepth)
+        {
+            list.Add(CreateGameObjectEntry(go, depth));
 
             if (depth < maxDepth)
             {
@@ -142,6 +209,140 @@ namespace UCP.Bridge
             }
         }
 
+        private static void QueryHierarchy(
+            GameObject go,
+            SceneQuery query,
+            HashSet<string> fields,
+            List<object> results,
+            int depth,
+            int maxDepth)
+        {
+            if (MatchesQuery(go, query))
+                results.Add(ProjectGameObject(go, fields, depth));
+
+            if (depth >= maxDepth)
+                return;
+
+            for (int i = 0; i < go.transform.childCount; i++)
+                QueryHierarchy(go.transform.GetChild(i).gameObject, query, fields, results, depth + 1, maxDepth);
+        }
+
+        private static Dictionary<string, object> ProjectGameObject(GameObject go, HashSet<string> fields, int depth)
+        {
+            var entry = new Dictionary<string, object>();
+            AddField(entry, fields, "instanceId", go.GetInstanceID());
+            AddField(entry, fields, "name", go.name);
+            AddField(entry, fields, "active", go.activeSelf);
+            AddField(entry, fields, "activeInHierarchy", go.activeInHierarchy);
+            AddField(entry, fields, "tag", go.tag);
+            AddField(entry, fields, "layer", go.layer);
+            AddField(entry, fields, "layerName", LayerMask.LayerToName(go.layer));
+            AddField(entry, fields, "depth", depth);
+            AddField(entry, fields, "childCount", go.transform.childCount);
+            AddField(entry, fields, "components", GetComponentTypes(go));
+            return entry;
+        }
+
+        private static void AddField(Dictionary<string, object> entry, HashSet<string> fields, string key, object value)
+        {
+            if (fields.Contains(key))
+                entry[key] = value;
+        }
+
+        private static HashSet<string> ParseFields(string raw)
+        {
+            var source = string.IsNullOrEmpty(raw) ? "instanceId,name,active,components" : raw;
+            return new HashSet<string>(
+                source.Split(new[] { ',' }, StringSplitOptions.RemoveEmptyEntries)
+                    .Select(field => field.Trim()),
+                StringComparer.OrdinalIgnoreCase);
+        }
+
+        private static SceneQuery ParseSceneQuery(string raw)
+        {
+            var query = new SceneQuery { Raw = raw ?? string.Empty };
+            foreach (var token in SplitQuery(query.Raw))
+            {
+                var index = token.IndexOf('=');
+                if (index <= 0)
+                    throw new ArgumentException($"Unsupported query token '{token}'. Use key=value.");
+
+                var key = token.Substring(0, index).Trim().ToLowerInvariant();
+                var value = token.Substring(index + 1).Trim().Trim('"');
+                switch (key)
+                {
+                    case "name":
+                        query.Name = value;
+                        break;
+                    case "component":
+                    case "components":
+                        query.Component = value;
+                        break;
+                    case "active":
+                        query.Active = Convert.ToBoolean(value);
+                        break;
+                    case "tag":
+                        query.Tag = value;
+                        break;
+                    case "layer":
+                        query.Layer = value;
+                        break;
+                    default:
+                        throw new ArgumentException($"Unsupported scene query key '{key}'");
+                }
+            }
+
+            return query;
+        }
+
+        private static IEnumerable<string> SplitQuery(string raw)
+        {
+            return (raw ?? string.Empty)
+                .Replace(" AND ", " and ")
+                .Split(new[] { " and ", "," }, StringSplitOptions.RemoveEmptyEntries)
+                .Select(token => token.Trim())
+                .Where(token => token.Length > 0);
+        }
+
+        private static bool MatchesQuery(GameObject go, SceneQuery query)
+        {
+            if (!string.IsNullOrEmpty(query.Name)
+                && !go.name.Contains(query.Name, StringComparison.OrdinalIgnoreCase))
+                return false;
+            if (!string.IsNullOrEmpty(query.Component) && !HasComponent(go, query.Component))
+                return false;
+            if (query.Active.HasValue && go.activeSelf != query.Active.Value)
+                return false;
+            if (!string.IsNullOrEmpty(query.Tag) && !string.Equals(go.tag, query.Tag, StringComparison.OrdinalIgnoreCase))
+                return false;
+            if (!string.IsNullOrEmpty(query.Layer) && !LayerMatches(go.layer, query.Layer))
+                return false;
+
+            return true;
+        }
+
+        private static bool HasComponent(GameObject go, string componentName)
+        {
+            foreach (var component in go.GetComponents<Component>())
+            {
+                if (component == null)
+                    continue;
+                var type = component.GetType();
+                if (type.Name.Equals(componentName, StringComparison.OrdinalIgnoreCase)
+                    || (type.FullName != null && type.FullName.Equals(componentName, StringComparison.OrdinalIgnoreCase)))
+                    return true;
+            }
+
+            return false;
+        }
+
+        private static bool LayerMatches(int layer, string expected)
+        {
+            if (int.TryParse(expected, out var parsed))
+                return layer == parsed;
+            return string.Equals(LayerMask.LayerToName(layer), expected, StringComparison.OrdinalIgnoreCase);
+        }
+
         private static object HandleGetComponents(string paramsJson)
         {
             var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
@@ -202,8 +403,92 @@ namespace UCP.Bridge
 
         private static GameObject FindByInstanceId(int id)
         {
-            var obj = UnityObjectCompat.ResolveByInstanceId(id);
-            return obj as GameObject;
+            var direct = UnityObjectCompat.ResolveByInstanceId<GameObject>(id);
+            if (direct != null)
+                return direct;
+
+            for (int i = 0; i < SceneManager.sceneCount; i++)
+            {
+                var scene = SceneManager.GetSceneAt(i);
+                if (!scene.isLoaded)
+                    continue;
+
+                foreach (var root in scene.GetRootGameObjects())
+                {
+                    var found = FindInHierarchy(root, id);
+                    if (found != null)
+                        return found;
+                }
+            }
+
+            return null;
+        }
+
+        private static GameObject FindInHierarchy(GameObject go, int instanceId)
+        {
+            if (go.GetInstanceID() == instanceId)
+                return go;
+
+            for (int i = 0; i < go.transform.childCount; i++)
+            {
+                var found = FindInHierarchy(go.transform.GetChild(i).gameObject, instanceId);
+                if (found != null)
+                    return found;
+            }
+
+            return null;
+        }
+
+        private static Dictionary<string, object> SerializeGameObjectTree(
+            GameObject go,
+            int depth,
+            int maxDepth,
+            ref int objectCount,
+            ref int componentCount)
+        {
+            objectCount++;
+
+            var entry = CreateGameObjectEntry(go, depth, ref componentCount);
+            if (depth < maxDepth)
+            {
+                var children = new List<object>();
+                for (int i = 0; i < go.transform.childCount; i++)
+                {
+                    children.Add(SerializeGameObjectTree(
+                        go.transform.GetChild(i).gameObject,
+                        depth + 1,
+                        maxDepth,
+                        ref objectCount,
+                        ref componentCount));
+                }
+
+                if (children.Count > 0)
+                    entry["children"] = children;
+            }
+
+            return entry;
+        }
+
+        private static Dictionary<string, object> CreateGameObjectEntry(GameObject go, int depth)
+        {
+            int ignored = 0;
+            return CreateGameObjectEntry(go, depth, ref ignored);
+        }
+
+        private static Dictionary<string, object> CreateGameObjectEntry(GameObject go, int depth, ref int componentCount)
+        {
+            return new Dictionary<string, object>
+            {
+                ["instanceId"] = go.GetInstanceID(),
+                ["name"] = go.name,
+                ["active"] = go.activeSelf,
+                ["tag"] = go.tag,
+                ["layer"] = go.layer,
+                ["layerName"] = LayerMask.LayerToName(go.layer),
+                ["childCount"] = go.transform.childCount,
+                ["components"] = GetComponentTypes(go, ref componentCount),
+                ["depth"] = depth
+            };
         }
 
         private static List<object> GetComponentTypes(GameObject go)
@@ -223,5 +508,15 @@ namespace UCP.Bridge
             }
             return componentTypes;
         }
+
+        private sealed class SceneQuery
+        {
+            public string Raw;
+            public string Name;
+            public string Component;
+            public bool? Active;
+            public string Tag;
+            public string Layer;
+        }
     }
 }

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)}";
+            }
         }
     }
 }