@mflrevan/ucp 0.5.1 → 0.5.2

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/Tests/Editor/ControllerSmokeTests.cs

@@ -435,6 +435,78 @@ namespace UCP.Bridge.Tests
             Assert.That(Convert.ToInt32(byLevel["error"]), Is.EqualTo(1));
         }
 
+        [Test]
+        public void LogsStatus_BackfillsConsoleEntriesWhenHistoryStartsEmpty()
+        {
+            LogsController.SetConsoleBackfillProviderForTests(() => new List<LogsController.ConsoleBackfillEntry>
+            {
+                new LogsController.ConsoleBackfillEntry { Level = "warning", Message = "Compiler warning" },
+                new LogsController.ConsoleBackfillEntry { Level = "error", Message = "Compiler error" }
+            });
+
+            var response = _router.Dispatch("logs/status", 1, "{}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToInt32(result["total"]), Is.EqualTo(2));
+
+            var byLevel = (Dictionary<string, object>)result["byLevel"];
+            Assert.That(Convert.ToInt32(byLevel["warning"]), Is.EqualTo(1));
+            Assert.That(Convert.ToInt32(byLevel["error"]), Is.EqualTo(1));
+        }
+
+        [Test]
+        public void LogsTail_BackfillIgnoresUcpBridgeNoise()
+        {
+            LogsController.SetConsoleBackfillProviderForTests(() => new List<LogsController.ConsoleBackfillEntry>
+            {
+                new LogsController.ConsoleBackfillEntry { Level = "info", Message = "[UCP] Bridge server started on port 21342" },
+                new LogsController.ConsoleBackfillEntry { Level = "warning", Message = "User-facing warning" }
+            });
+
+            var response = _router.Dispatch("logs/tail", 1, "{\"count\":20}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToInt32(result["total"]), Is.EqualTo(1));
+
+            var logs = (List<object>)result["logs"];
+            var only = (Dictionary<string, object>)logs[0];
+            Assert.That(only["messagePreview"], Is.EqualTo("User-facing warning"));
+        }
+
+        [Test]
+        public void LogsGet_CanReadBackfilledConsoleEntries()
+        {
+            LogsController.SetConsoleBackfillProviderForTests(() => new List<LogsController.ConsoleBackfillEntry>
+            {
+                new LogsController.ConsoleBackfillEntry
+                {
+                    Level = "exception",
+                    Message = "Backfilled exception",
+                    StackTrace = "stack line 1\nstack line 2"
+                }
+            });
+
+            var tail = _router.Dispatch("logs/tail", 1, "{\"count\":20}");
+            Assert.That(tail.error, Is.Null);
+
+            var tailResult = (Dictionary<string, object>)tail.result;
+            var logs = (List<object>)tailResult["logs"];
+            var first = (Dictionary<string, object>)logs[0];
+            var id = Convert.ToInt64(first["id"]);
+
+            var get = _router.Dispatch("logs/get", 1, "{\"id\":" + id + "}");
+            Assert.That(get.error, Is.Null);
+
+            var getResult = (Dictionary<string, object>)get.result;
+            Assert.That(getResult["level"], Is.EqualTo("exception"));
+            Assert.That(getResult["message"], Is.EqualTo("Backfilled exception"));
+            Assert.That(getResult["stackTrace"], Is.EqualTo("stack line 1\nstack line 2"));
+        }
+
         [Test]
         public void ObjectLifecycle_CreateMutateAndDelete_WorksEndToEnd()
         {

package/bridge/com.ucp.bridge/package.json

@@ -1,6 +1,6 @@
 {
   "name": "com.ucp.bridge",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "displayName": "Unity Control Protocol Bridge",
   "description": "WebSocket bridge for programmatic Unity Editor control via CLI and AI agents.",
   "unity": "2021.3",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@mflrevan/ucp",
-  "version": "0.5.1",
+  "version": "0.5.2",
   "description": "Unity Control Protocol - CLI for programmatic Unity Editor control",
   "license": "MIT",
   "repository": {