@mflrevan/ucp 0.2.0 → 0.2.3

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

@@ -0,0 +1,319 @@
+using System;
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UCP.Bridge
+{
+    public static class HierarchyController
+    {
+        public static void Register(CommandRouter router)
+        {
+            router.Register("object/create", HandleCreate);
+            router.Register("object/delete", HandleDelete);
+            router.Register("object/reparent", HandleReparent);
+            router.Register("object/instantiate", HandleInstantiate);
+            router.Register("object/add-component", HandleAddComponent);
+            router.Register("object/remove-component", HandleRemoveComponent);
+        }
+
+        private static object HandleCreate(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var name = "GameObject";
+            if (p != null && p.TryGetValue("name", out var nameObj) && nameObj != null)
+                name = nameObj.ToString();
+
+            var go = new GameObject(name);
+            Undo.RegisterCreatedObjectUndo(go, "UCP Create GameObject");
+
+            // Optional parent
+            if (p != null && p.TryGetValue("parent", out var parentObj))
+            {
+                int parentId = Convert.ToInt32(parentObj);
+                var parent = FindGameObject(parentId);
+                go.transform.SetParent(parent.transform, false);
+            }
+
+            // Optional position
+            if (p != null && p.TryGetValue("position", out var posObj) && posObj is List<object> pos && pos.Count >= 3)
+            {
+                go.transform.localPosition = new Vector3(
+                    Convert.ToSingle(pos[0]),
+                    Convert.ToSingle(pos[1]),
+                    Convert.ToSingle(pos[2]));
+            }
+
+            // Optional rotation (euler angles)
+            if (p != null && p.TryGetValue("rotation", out var rotObj) && rotObj is List<object> rot && rot.Count >= 3)
+            {
+                go.transform.localEulerAngles = new Vector3(
+                    Convert.ToSingle(rot[0]),
+                    Convert.ToSingle(rot[1]),
+                    Convert.ToSingle(rot[2]));
+            }
+
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = go.GetInstanceID(),
+                ["name"] = go.name
+            };
+        }
+
+        private static object HandleDelete(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);
+            var go = FindGameObject(instanceId);
+            string name = go.name;
+
+            Undo.DestroyObjectImmediate(go);
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["deleted"] = name,
+                ["instanceId"] = instanceId
+            };
+        }
+
+        private static object HandleReparent(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);
+            var go = FindGameObject(instanceId);
+
+            Undo.SetTransformParent(go.transform, null, "UCP Reparent");
+
+            if (p.TryGetValue("parent", out var parentObj) && parentObj != null)
+            {
+                int parentId = Convert.ToInt32(parentObj);
+                var parent = FindGameObject(parentId);
+                Undo.SetTransformParent(go.transform, parent.transform, "UCP Reparent");
+            }
+            // else: parent = null means move to root
+
+            // Optional sibling index
+            if (p.TryGetValue("siblingIndex", out var sibObj))
+            {
+                go.transform.SetSiblingIndex(Convert.ToInt32(sibObj));
+            }
+
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = instanceId,
+                ["name"] = go.name,
+                ["parent"] = go.transform.parent != null ? go.transform.parent.gameObject.name : null
+            };
+        }
+
+        private static object HandleInstantiate(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null)
+                throw new ArgumentException("Missing parameters");
+
+            GameObject source = null;
+
+            // Instantiate from prefab asset path
+            if (p.TryGetValue("prefab", out var prefabObj) && prefabObj != null)
+            {
+                string prefabPath = prefabObj.ToString();
+                var prefab = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
+                if (prefab == null)
+                    throw new ArgumentException($"Prefab not found: {prefabPath}");
+                source = prefab;
+            }
+            // Instantiate from existing scene object (clone)
+            else if (p.TryGetValue("sourceId", out var srcObj))
+            {
+                int srcId = Convert.ToInt32(srcObj);
+                source = FindGameObject(srcId);
+            }
+            else
+            {
+                throw new ArgumentException("Must provide 'prefab' (asset path) or 'sourceId' (instanceId)");
+            }
+
+            var instance = (GameObject)PrefabUtility.InstantiatePrefab(source);
+            if (instance == null)
+            {
+                // Fallback for non-prefab objects (e.g. cloning scene objects)
+                instance = UnityEngine.Object.Instantiate(source);
+            }
+
+            Undo.RegisterCreatedObjectUndo(instance, "UCP Instantiate");
+
+            // Optional parent
+            if (p.TryGetValue("parent", out var parentObj) && parentObj != null)
+            {
+                int parentId = Convert.ToInt32(parentObj);
+                var parent = FindGameObject(parentId);
+                instance.transform.SetParent(parent.transform, false);
+            }
+
+            // Optional name override
+            if (p.TryGetValue("name", out var nameObj) && nameObj != null)
+            {
+                instance.name = nameObj.ToString();
+            }
+
+            // Optional position
+            if (p.TryGetValue("position", out var posObj) && posObj is List<object> pos && pos.Count >= 3)
+            {
+                instance.transform.localPosition = new Vector3(
+                    Convert.ToSingle(pos[0]),
+                    Convert.ToSingle(pos[1]),
+                    Convert.ToSingle(pos[2]));
+            }
+
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = instance.GetInstanceID(),
+                ["name"] = instance.name
+            };
+        }
+
+        private static object HandleAddComponent(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");
+            if (!p.TryGetValue("type", out var typeObj) || typeObj == null)
+                throw new ArgumentException("Missing 'type' parameter");
+
+            int instanceId = Convert.ToInt32(idObj);
+            var go = FindGameObject(instanceId);
+            string typeName = typeObj.ToString();
+
+            // Resolve component type
+            Type compType = ResolveComponentType(typeName);
+            if (compType == null)
+                throw new ArgumentException($"Component type not found: {typeName}");
+
+            var comp = Undo.AddComponent(go, compType);
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = instanceId,
+                ["component"] = comp.GetType().Name,
+                ["componentFullType"] = comp.GetType().FullName
+            };
+        }
+
+        private static object HandleRemoveComponent(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");
+            if (!p.TryGetValue("type", out var typeObj) || typeObj == null)
+                throw new ArgumentException("Missing 'type' parameter");
+
+            int instanceId = Convert.ToInt32(idObj);
+            var go = FindGameObject(instanceId);
+            string typeName = typeObj.ToString();
+
+            Component target = null;
+            foreach (var c in go.GetComponents<Component>())
+            {
+                if (c == null) continue;
+                if (c.GetType().Name == typeName || c.GetType().FullName == typeName)
+                {
+                    target = c;
+                    break;
+                }
+            }
+
+            if (target == null)
+                throw new ArgumentException($"Component '{typeName}' not found on '{go.name}'");
+            if (target is Transform)
+                throw new ArgumentException("Cannot remove Transform component");
+
+            Undo.DestroyObjectImmediate(target);
+            EditorSceneManager.MarkSceneDirty(SceneManager.GetActiveScene());
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["instanceId"] = instanceId,
+                ["removed"] = typeName
+            };
+        }
+
+        private static Type ResolveComponentType(string typeName)
+        {
+            // Try exact match first
+            var type = Type.GetType(typeName);
+            if (type != null && typeof(Component).IsAssignableFrom(type))
+                return type;
+
+            // Search Unity assemblies
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                foreach (var t in assembly.GetTypes())
+                {
+                    if (!typeof(Component).IsAssignableFrom(t)) continue;
+                    if (t.Name == typeName || t.FullName == typeName)
+                        return t;
+                }
+            }
+
+            // Common Unity types fallback
+            var unityType = Type.GetType($"UnityEngine.{typeName}, UnityEngine.CoreModule");
+            if (unityType != null && typeof(Component).IsAssignableFrom(unityType))
+                return unityType;
+
+            return null;
+        }
+
+        private static GameObject FindGameObject(int instanceId)
+        {
+            var obj = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
+            if (obj != null) return obj;
+
+            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, instanceId);
+                    if (found != null) return found;
+                }
+            }
+
+            throw new ArgumentException($"GameObject not found: {instanceId}");
+        }
+
+        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;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 8d90db77ca2967941a28a26f7af1adfe

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

@@ -0,0 +1,291 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text.RegularExpressions;
+using UnityEngine;
+
+namespace UCP.Bridge
+{
+    public static class LogsController
+    {
+        private const int MaxHistoryEntries = 2000;
+        private const int MaxBulkResults = 10;
+        private const int DefaultSearchWindow = 200;
+        private const int MaxPreviewLength = 200;
+
+        private static readonly object s_historyLock = new object();
+        private static readonly List<LogRecord> s_history = new List<LogRecord>();
+        private static long s_nextId = 1;
+
+        public static void Register(CommandRouter router)
+        {
+            router.Register("logs/subscribe", _ => new Dictionary<string, object> { ["subscribed"] = true });
+            router.Register("logs/unsubscribe", _ => new Dictionary<string, object> { ["unsubscribed"] = true });
+            router.Register("logs/tail", HandleTail);
+            router.Register("logs/search", HandleSearch);
+            router.Register("logs/get", HandleGet);
+        }
+
+        public static Dictionary<string, object> RecordLog(string message, string stackTrace, LogType type)
+        {
+            return RecordLog(NormalizeLevel(type), message, stackTrace);
+        }
+
+        public static void ClearHistoryForTests()
+        {
+            lock (s_historyLock)
+            {
+                s_history.Clear();
+                s_nextId = 1;
+            }
+        }
+
+        public static Dictionary<string, object> RecordTestLog(string level, string message, string stackTrace = "")
+        {
+            return RecordLog(level, message, stackTrace);
+        }
+
+        private static object HandleTail(string paramsJson)
+        {
+            var query = ParseQuery(paramsJson, includePattern: false);
+            return BuildListResult(QueryHistory(query));
+        }
+
+        private static object HandleSearch(string paramsJson)
+        {
+            var query = ParseQuery(paramsJson, includePattern: true);
+            return BuildListResult(QueryHistory(query));
+        }
+
+        private static object HandleGet(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            if (p == null || !p.TryGetValue("id", out var idObj))
+                throw new ArgumentException("Missing 'id' parameter");
+
+            long id = Convert.ToInt64(idObj);
+
+            lock (s_historyLock)
+            {
+                var entry = s_history.FirstOrDefault(record => record.Id == id);
+                if (entry == null)
+                    throw new ArgumentException($"Log entry not found: {id}");
+
+                return SerializeFull(entry);
+            }
+        }
+
+        private static Dictionary<string, object> RecordLog(string level, string message, string stackTrace)
+        {
+            lock (s_historyLock)
+            {
+                var entry = new LogRecord
+                {
+                    Id = s_nextId++,
+                    Level = NormalizeLevel(level),
+                    Message = message ?? string.Empty,
+                    StackTrace = stackTrace ?? string.Empty,
+                    Timestamp = DateTime.UtcNow.ToString("o")
+                };
+
+                s_history.Add(entry);
+                if (s_history.Count > MaxHistoryEntries)
+                    s_history.RemoveAt(0);
+
+                return SerializeFull(entry);
+            }
+        }
+
+        private static LogQuery ParseQuery(string paramsJson, bool includePattern)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var query = new LogQuery();
+
+            if (p != null)
+            {
+                if (p.TryGetValue("level", out var levelObj) && levelObj != null)
+                    query.Level = NormalizeLevel(levelObj.ToString());
+                if (p.TryGetValue("count", out var countObj) && countObj != null)
+                    query.Count = Math.Max(1, Convert.ToInt32(countObj));
+                if (p.TryGetValue("beforeId", out var beforeObj) && beforeObj != null)
+                    query.BeforeId = Convert.ToInt64(beforeObj);
+                if (p.TryGetValue("afterId", out var afterObj) && afterObj != null)
+                    query.AfterId = Convert.ToInt64(afterObj);
+
+                if (includePattern && p.TryGetValue("pattern", out var patternObj) && patternObj != null)
+                {
+                    query.Pattern = patternObj.ToString();
+                    try
+                    {
+                        query.Regex = new Regex(query.Pattern, RegexOptions.IgnoreCase | RegexOptions.CultureInvariant);
+                    }
+                    catch (Exception ex)
+                    {
+                        throw new ArgumentException($"Invalid regex pattern: {ex.Message}");
+                    }
+                }
+            }
+
+            if (query.Count <= 0)
+                query.Count = DefaultSearchWindow;
+
+            return query;
+        }
+
+        private static LogQueryResult QueryHistory(LogQuery query)
+        {
+            lock (s_historyLock)
+            {
+                IEnumerable<LogRecord> candidates = s_history;
+
+                if (query.BeforeId.HasValue)
+                    candidates = candidates.Where(entry => entry.Id < query.BeforeId.Value);
+                if (query.AfterId.HasValue)
+                    candidates = candidates.Where(entry => entry.Id > query.AfterId.Value);
+                if (!string.IsNullOrEmpty(query.Level))
+                    candidates = candidates.Where(entry => PassesLevel(entry.Level, query.Level));
+
+                candidates = candidates.OrderByDescending(entry => entry.Id).Take(query.Count);
+
+                if (query.Regex != null)
+                {
+                    candidates = candidates.Where(entry =>
+                        query.Regex.IsMatch(entry.Message)
+                        || (!string.IsNullOrEmpty(entry.StackTrace) && query.Regex.IsMatch(entry.StackTrace))
+                    );
+                }
+
+                var allMatches = candidates.ToList();
+                var returned = allMatches.Take(MaxBulkResults).Select(SerializeSummary).ToList();
+
+                return new LogQueryResult
+                {
+                    Total = allMatches.Count,
+                    Returned = returned,
+                    Truncated = allMatches.Count > MaxBulkResults
+                };
+            }
+        }
+
+        private static Dictionary<string, object> BuildListResult(LogQueryResult queryResult)
+        {
+            return new Dictionary<string, object>
+            {
+                ["logs"] = queryResult.Returned.Cast<object>().ToList(),
+                ["total"] = queryResult.Total,
+                ["returned"] = queryResult.Returned.Count,
+                ["truncated"] = queryResult.Truncated
+            };
+        }
+
+        private static Dictionary<string, object> SerializeSummary(LogRecord entry)
+        {
+            return new Dictionary<string, object>
+            {
+                ["id"] = entry.Id,
+                ["level"] = entry.Level,
+                ["timestamp"] = entry.Timestamp,
+                ["messagePreview"] = Preview(entry.Message, MaxPreviewLength),
+                ["hasStackTrace"] = !string.IsNullOrEmpty(entry.StackTrace)
+            };
+        }
+
+        private static Dictionary<string, object> SerializeFull(LogRecord entry)
+        {
+            return new Dictionary<string, object>
+            {
+                ["id"] = entry.Id,
+                ["level"] = entry.Level,
+                ["timestamp"] = entry.Timestamp,
+                ["message"] = entry.Message,
+                ["stackTrace"] = entry.StackTrace
+            };
+        }
+
+        private static bool PassesLevel(string value, string threshold)
+        {
+            return Severity(value) >= Severity(threshold);
+        }
+
+        private static int Severity(string level)
+        {
+            switch (NormalizeLevel(level))
+            {
+                case "error":
+                case "exception":
+                    return 2;
+                case "warning":
+                    return 1;
+                default:
+                    return 0;
+            }
+        }
+
+        private static string NormalizeLevel(LogType type)
+        {
+            switch (type)
+            {
+                case LogType.Error:
+                case LogType.Assert:
+                    return "error";
+                case LogType.Exception:
+                    return "exception";
+                case LogType.Warning:
+                    return "warning";
+                default:
+                    return "info";
+            }
+        }
+
+        private static string NormalizeLevel(string level)
+        {
+            if (string.IsNullOrEmpty(level))
+                return "info";
+
+            var normalized = level.Trim().ToLowerInvariant();
+            switch (normalized)
+            {
+                case "warn":
+                    return "warning";
+                case "err":
+                    return "error";
+                default:
+                    return normalized;
+            }
+        }
+
+        private static string Preview(string value, int maxChars)
+        {
+            if (string.IsNullOrEmpty(value) || value.Length <= maxChars)
+                return value ?? string.Empty;
+
+            return value.Substring(0, maxChars) + "...";
+        }
+
+        private sealed class LogRecord
+        {
+            public long Id;
+            public string Level;
+            public string Message;
+            public string StackTrace;
+            public string Timestamp;
+        }
+
+        private sealed class LogQuery
+        {
+            public string Level;
+            public string Pattern;
+            public Regex Regex;
+            public int Count;
+            public long? BeforeId;
+            public long? AfterId;
+        }
+
+        private sealed class LogQueryResult
+        {
+            public int Total;
+            public List<Dictionary<string, object>> Returned;
+            public bool Truncated;
+        }
+    }
+}

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

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 76c15fe92f2848f0a69e0b37b4d8c9a1