@mflrevan/ucp 0.4.6 → 0.5.1

package/bridge/com.ucp.bridge/Tests/Editor/ControllerSmokeTests.cs

@@ -21,6 +21,15 @@ namespace UCP.Bridge.Tests
         private const string TempTextPath = "Assets/UcpControllerSmoke.txt";
         private const string TempScriptPath = "Assets/UcpControllerSmokeComponent.cs";
         private const string TempTexturePath = "Assets/UcpImporterSmoke.png";
+        private const string TempScenePath = "Assets/UcpControllerMoveScene.unity";
+        private const string TempSceneBPath = "Assets/UcpControllerSceneB.unity";
+        private const string TempMovedFolderPath = "Assets/UcpControllerMoved";
+        private const string TempMovedAssetPath = "Assets/UcpControllerMoved/UcpControllerSmoke.asset";
+        private const string TempMovedReferenceAssetPath = "Assets/UcpControllerMoved/UcpControllerReference.asset";
+        private const string TempMovedMaterialPath = "Assets/UcpControllerMoved/UcpControllerSmoke.mat";
+        private const string TempMovedScenePath = "Assets/UcpControllerMoved/UcpControllerMoveScene.unity";
+        private const string TempReimportFolderPath = "Assets/UcpRecursiveReimport";
+        private const string TempReimportTexturePath = "Assets/UcpRecursiveReimport/UcpRecursiveA.png";
         private const string TempProfilerExportPath = "ProfilerCaptures\\smoke-export.json";
         private const string TempLocalPackageFolder = "TempUcpLocalPackage";
         private const string TempLocalPackageName = "com.ucp.temp.local";
@@ -34,6 +43,8 @@ namespace UCP.Bridge.Tests
             SnapshotController.Register(_router);
             AssetController.Register(_router);
             ImporterController.Register(_router);
+            PlayModeController.Register(_router);
+            ReferenceController.Register(_router);
             LogsController.Register(_router);
             HierarchyController.Register(_router);
             ProfilerController.Register(_router);
@@ -53,6 +64,10 @@ namespace UCP.Bridge.Tests
             DeleteTempTextFile();
             DeleteTempScriptFile();
             DeleteTempTextureAsset();
+            DeleteTempScene();
+            DeleteTempSceneB();
+            DeleteTempMovedFolder();
+            DeleteTempReimportFolder();
             DeleteTempProfilerExport();
             DeleteTempLocalPackage();
             RemoveTempLocalPackageDependencyIfPresent();
@@ -74,6 +89,10 @@ namespace UCP.Bridge.Tests
             DeleteTempTextFile();
             DeleteTempScriptFile();
             DeleteTempTextureAsset();
+            DeleteTempScene();
+            DeleteTempSceneB();
+            DeleteTempMovedFolder();
+            DeleteTempReimportFolder();
             DeleteTempProfilerExport();
             DeleteTempLocalPackage();
             RemoveTempLocalPackageDependencyIfPresent();
@@ -236,6 +255,64 @@ namespace UCP.Bridge.Tests
             Assert.That(Convert.ToBoolean(match["isSubAsset"]), Is.True);
         }
 
+        [Test]
+        public void AssetSearch_SupportsRegexNameFiltering()
+        {
+            const string RegexAssetPath = "Assets/SCN_101.asset";
+
+            try
+            {
+                var sceneAsset = ScriptableObject.CreateInstance<SearchRootAsset>();
+                sceneAsset.name = "SCN_101";
+                AssetDatabase.CreateAsset(sceneAsset, RegexAssetPath);
+                AssetDatabase.SaveAssets();
+
+                var response = _router.Dispatch(
+                    "asset/search",
+                    1,
+                    "{\"name\":\"^SCN_[0-9]+$\",\"regex\":true,\"path\":\"Assets\",\"maxResults\":10}");
+
+                Assert.That(response.error, Is.Null);
+
+                var result = (Dictionary<string, object>)response.result;
+                var matches = (List<object>)result["results"];
+                var match = FindAssetMatchByPath(matches, RegexAssetPath);
+                Assert.That(match, Is.Not.Null);
+            }
+            finally
+            {
+                if (AssetDatabase.AssetPathExists(RegexAssetPath))
+                {
+                    AssetDatabase.DeleteAsset(RegexAssetPath);
+                    AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+                }
+            }
+        }
+
+        [Test]
+        public void AssetSearch_DoesNotEmitSceneReadObjectThreadedErrors()
+        {
+            EditorSceneManager.NewScene(NewSceneSetup.DefaultGameObjects, NewSceneMode.Single);
+            EditorSceneManager.SaveScene(UnityEngine.SceneManagement.SceneManager.GetActiveScene(), TempScenePath);
+            AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+            LogsController.ClearHistoryForTests();
+
+            var response = _router.Dispatch(
+                "asset/search",
+                1,
+                "{\"name\":\"UcpControllerMoveScene\",\"path\":\"Assets\",\"maxResults\":10}");
+
+            Assert.That(response.error, Is.Null);
+
+            var status = _router.Dispatch("logs/status", 1, "{}");
+            Assert.That(status.error, Is.Null);
+
+            var result = (Dictionary<string, object>)status.result;
+            var byLevel = (Dictionary<string, object>)result["byLevel"];
+            Assert.That(Convert.ToInt32(byLevel["error"]), Is.EqualTo(0));
+            Assert.That(Convert.ToInt32(byLevel["exception"]), Is.EqualTo(0));
+        }
+
         [Test]
         public void LogsTail_ReturnsRequestedBufferedCount()
         {
@@ -334,6 +411,30 @@ namespace UCP.Bridge.Tests
             Assert.That(result["stackTrace"], Is.EqualTo("stack line 1\nstack line 2"));
         }
 
+        [Test]
+        public void LogsStatus_CanScopeToNewEntriesAfterCursor()
+        {
+            var first = LogsController.RecordTestLog("info", "Before");
+            LogsController.RecordTestLog("warning", "After warning");
+            LogsController.RecordTestLog("error", "After error");
+
+            var response = _router.Dispatch(
+                "logs/status",
+                1,
+                "{\"afterId\":" + Convert.ToInt64(first["id"]) + "}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToInt64(result["afterId"]), Is.EqualTo(Convert.ToInt64(first["id"])));
+            Assert.That(Convert.ToInt32(result["total"]), Is.EqualTo(2));
+
+            var byLevel = (Dictionary<string, object>)result["byLevel"];
+            Assert.That(Convert.ToInt32(byLevel["info"]), Is.EqualTo(0));
+            Assert.That(Convert.ToInt32(byLevel["warning"]), Is.EqualTo(1));
+            Assert.That(Convert.ToInt32(byLevel["error"]), Is.EqualTo(1));
+        }
+
         [Test]
         public void ObjectLifecycle_CreateMutateAndDelete_WorksEndToEnd()
         {
@@ -477,6 +578,166 @@ namespace UCP.Bridge.Tests
             Assert.That(AssetDatabase.GetAssetPath(reloaded.referenceAsset), Is.EqualTo(TempReferenceAssetPath));
         }
 
+        [Test]
+        public void AssetMove_PreservesCustomAssetReferenceAndGuid()
+        {
+            var reference = ScriptableObject.CreateInstance<SearchRootAsset>();
+            reference.name = "MoveTarget";
+            AssetDatabase.CreateAsset(reference, TempReferenceAssetPath);
+
+            var asset = ScriptableObject.CreateInstance<BatchWritableAsset>();
+            asset.referenceAsset = reference;
+            AssetDatabase.CreateAsset(asset, TempAssetPath);
+            AssetDatabase.SaveAssets();
+
+            var originalGuid = AssetDatabase.AssetPathToGUID(TempReferenceAssetPath);
+
+            var response = _router.Dispatch(
+                "asset/move",
+                1,
+                "{\"path\":\"" + TempReferenceAssetPath + "\",\"destination\":\"" + TempMovedReferenceAssetPath + "\"}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToBoolean(result["changed"]), Is.True);
+            Assert.That(result["sourcePath"], Is.EqualTo(TempReferenceAssetPath));
+            Assert.That(result["destinationPath"], Is.EqualTo(TempMovedReferenceAssetPath));
+            Assert.That(result["guid"], Is.EqualTo(originalGuid));
+
+            var reloaded = AssetDatabase.LoadAssetAtPath<BatchWritableAsset>(TempAssetPath);
+            Assert.That(reloaded, Is.Not.Null);
+            Assert.That(reloaded.referenceAsset, Is.Not.Null);
+            Assert.That(AssetDatabase.GetAssetPath(reloaded.referenceAsset), Is.EqualTo(TempMovedReferenceAssetPath));
+            Assert.That(AssetDatabase.AssetPathToGUID(TempMovedReferenceAssetPath), Is.EqualTo(originalGuid));
+        }
+
+        [Test]
+        public void AssetBulkMove_MovesMultipleAssetsAndPreservesReferences()
+        {
+            var reference = ScriptableObject.CreateInstance<SearchRootAsset>();
+            reference.name = "BulkMoveRef";
+            AssetDatabase.CreateAsset(reference, TempReferenceAssetPath);
+
+            var asset = ScriptableObject.CreateInstance<BatchWritableAsset>();
+            asset.referenceAsset = reference;
+            asset.maxPlayers = 7;
+            AssetDatabase.CreateAsset(asset, TempAssetPath);
+            AssetDatabase.SaveAssets();
+
+            var response = _router.Dispatch(
+                "asset/bulk-move",
+                1,
+                "{\"moves\":["
+                + "{\"from\":\"" + TempReferenceAssetPath + "\",\"to\":\"" + TempMovedReferenceAssetPath + "\"},"
+                + "{\"from\":\"" + TempAssetPath + "\",\"to\":\"" + TempMovedAssetPath + "\"}"
+                + "]}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToInt32(result["requested"]), Is.EqualTo(2));
+            Assert.That(Convert.ToInt32(result["moved"]), Is.EqualTo(2));
+            Assert.That(Convert.ToInt32(result["failed"]), Is.EqualTo(0));
+
+            var movedAsset = AssetDatabase.LoadAssetAtPath<BatchWritableAsset>(TempMovedAssetPath);
+            Assert.That(movedAsset, Is.Not.Null);
+            Assert.That(movedAsset.maxPlayers, Is.EqualTo(7));
+            Assert.That(movedAsset.referenceAsset, Is.Not.Null);
+            Assert.That(AssetDatabase.GetAssetPath(movedAsset.referenceAsset), Is.EqualTo(TempMovedReferenceAssetPath));
+        }
+
+        [Test]
+        public void AssetBulkMove_DryRunDoesNotMutateProject()
+        {
+            var asset = ScriptableObject.CreateInstance<SearchRootAsset>();
+            asset.name = "DryRunAsset";
+            AssetDatabase.CreateAsset(asset, TempAssetPath);
+            AssetDatabase.SaveAssets();
+
+            var response = _router.Dispatch(
+                "asset/bulk-move",
+                1,
+                "{\"dryRun\":true,\"moves\":[{\"from\":\"" + TempAssetPath + "\",\"to\":\"" + TempMovedAssetPath + "\"}]}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToBoolean(result["dryRun"]), Is.True);
+            Assert.That(Convert.ToInt32(result["moved"]), Is.EqualTo(1));
+            Assert.That(AssetDatabase.LoadAssetAtPath<SearchRootAsset>(TempAssetPath), Is.Not.Null);
+            Assert.That(AssetDatabase.LoadAssetAtPath<SearchRootAsset>(TempMovedAssetPath), Is.Null);
+        }
+
+        [Test]
+        public void AssetMove_PreservesSceneMaterialReference()
+        {
+            var shader = Shader.Find("Universal Render Pipeline/Lit") ?? Shader.Find("Standard");
+            Assert.That(shader, Is.Not.Null);
+
+            var material = new Material(shader) { name = "MoveSceneMaterial" };
+            AssetDatabase.CreateAsset(material, TempMaterialPath);
+            AssetDatabase.SaveAssets();
+
+            var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+            var cube = GameObject.CreatePrimitive(PrimitiveType.Cube);
+            cube.name = "MoveSceneCube";
+            cube.GetComponent<MeshRenderer>().sharedMaterial = material;
+            Assert.That(EditorSceneManager.SaveScene(scene, TempScenePath), Is.True);
+
+            var response = _router.Dispatch(
+                "asset/move",
+                1,
+                "{\"path\":\"" + TempMaterialPath + "\",\"destination\":\"" + TempMovedMaterialPath + "\"}");
+
+            Assert.That(response.error, Is.Null);
+
+            EditorSceneManager.OpenScene(TempScenePath, OpenSceneMode.Single);
+            var movedCube = GameObject.Find("MoveSceneCube");
+            Assert.That(movedCube, Is.Not.Null);
+            var renderer = movedCube.GetComponent<MeshRenderer>();
+            Assert.That(renderer, Is.Not.Null);
+            Assert.That(renderer.sharedMaterial, Is.Not.Null);
+            Assert.That(AssetDatabase.GetAssetPath(renderer.sharedMaterial), Is.EqualTo(TempMovedMaterialPath));
+        }
+
+        [Test]
+        public void AssetMove_UpdatesBuildSettingsWhenSceneMoves()
+        {
+            var originalScenes = EditorBuildSettings.scenes;
+            try
+            {
+                var scene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+                var marker = new GameObject("MovedSceneMarker");
+                marker.transform.position = new Vector3(1f, 2f, 3f);
+                Assert.That(EditorSceneManager.SaveScene(scene, TempScenePath), Is.True);
+
+                var originalGuid = AssetDatabase.AssetPathToGUID(TempScenePath);
+                EditorBuildSettings.scenes = new[]
+                {
+                    new EditorBuildSettingsScene(TempScenePath, true)
+                };
+
+                var response = _router.Dispatch(
+                    "asset/move",
+                    1,
+                    "{\"path\":\"" + TempScenePath + "\",\"destination\":\"" + TempMovedScenePath + "\"}");
+
+                Assert.That(response.error, Is.Null);
+                Assert.That(AssetDatabase.AssetPathToGUID(TempMovedScenePath), Is.EqualTo(originalGuid));
+
+                Assert.That(EditorBuildSettings.scenes, Has.Length.EqualTo(1));
+                Assert.That(EditorBuildSettings.scenes[0].path, Is.EqualTo(TempMovedScenePath));
+
+                EditorSceneManager.OpenScene(TempMovedScenePath, OpenSceneMode.Single);
+                Assert.That(GameObject.Find("MovedSceneMarker"), Is.Not.Null);
+            }
+            finally
+            {
+                EditorBuildSettings.scenes = originalScenes;
+            }
+        }
+
         [Test]
         public void FileController_WritePatchRead_AndRejectsPathTraversal()
         {
@@ -610,6 +871,53 @@ namespace UCP.Bridge.Tests
             Assert.That(importer.isReadable, Is.True);
         }
 
+        [Test]
+        public void ImporterController_ReimportRecursive_ReimportsFolderContents()
+        {
+            CreateTempRecursiveTextureAsset(Color.magenta);
+            AssetImportSupport.ClearTestState();
+
+            var response = _router.Dispatch(
+                "asset/reimport",
+                1,
+                "{\"path\":\"" + TempReimportFolderPath + "\",\"recursive\":true}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToBoolean(result["recursive"]), Is.True);
+            Assert.That(Convert.ToInt32(result["requested"]), Is.GreaterThanOrEqualTo(1));
+            Assert.That(Convert.ToInt32(result["reimported"]), Is.GreaterThanOrEqualTo(1));
+            Assert.That(AssetImportSupport.LastReimportedPathForTests, Is.EqualTo(TempReimportTexturePath));
+        }
+
+        [Test]
+        public void SceneController_Load_AdditiveKeepsExistingSceneLoaded()
+        {
+            var firstScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+            new GameObject("SceneAObject");
+            Assert.That(EditorSceneManager.SaveScene(firstScene, TempScenePath), Is.True);
+
+            var secondScene = EditorSceneManager.NewScene(NewSceneSetup.EmptyScene, NewSceneMode.Single);
+            new GameObject("SceneBObject");
+            Assert.That(EditorSceneManager.SaveScene(secondScene, TempSceneBPath), Is.True);
+
+            EditorSceneManager.OpenScene(TempScenePath, OpenSceneMode.Single);
+
+            var response = _router.Dispatch(
+                "scene/load",
+                1,
+                "{\"path\":\"" + TempSceneBPath + "\",\"additive\":true,\"saveDirtyScenes\":true,\"discardUntitled\":true}");
+
+            Assert.That(response.error, Is.Null);
+
+            var result = (Dictionary<string, object>)response.result;
+            Assert.That(Convert.ToBoolean(result["additive"]), Is.True);
+            Assert.That(UnityEngine.SceneManagement.SceneManager.sceneCount, Is.EqualTo(2));
+            Assert.That(UnityEngine.SceneManagement.SceneManager.GetSceneByPath(TempScenePath).isLoaded, Is.True);
+            Assert.That(UnityEngine.SceneManagement.SceneManager.GetSceneByPath(TempSceneBPath).isLoaded, Is.True);
+        }
+
         [Test]
         public void PackagesController_DependencySetInfoAndRemove_LocalFilePackage()
         {
@@ -935,6 +1243,42 @@ namespace UCP.Bridge.Tests
             AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
         }
 
+        private static void DeleteTempScene()
+        {
+            if (AssetDatabase.LoadMainAssetAtPath(TempScenePath) != null)
+            {
+                AssetDatabase.DeleteAsset(TempScenePath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
+        private static void DeleteTempSceneB()
+        {
+            if (AssetDatabase.LoadMainAssetAtPath(TempSceneBPath) != null)
+            {
+                AssetDatabase.DeleteAsset(TempSceneBPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
+        private static void DeleteTempMovedFolder()
+        {
+            if (AssetDatabase.IsValidFolder(TempMovedFolderPath))
+            {
+                AssetDatabase.DeleteAsset(TempMovedFolderPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
+        private static void DeleteTempReimportFolder()
+        {
+            if (AssetDatabase.IsValidFolder(TempReimportFolderPath))
+            {
+                AssetDatabase.DeleteAsset(TempReimportFolderPath);
+                AssetDatabase.SaveAssets();
+            }
+        }
+
         private static void DeleteTempProfilerExport()
         {
             var fullPath = ResolveProjectRelativePath(TempProfilerExportPath);
@@ -1014,6 +1358,24 @@ namespace UCP.Bridge.Tests
                 ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
         }
 
+        private static void CreateTempRecursiveTextureAsset(Color color)
+        {
+            DeleteTempReimportFolder();
+            Directory.CreateDirectory(ResolveProjectRelativePath(TempReimportFolderPath));
+
+            var texture = new Texture2D(2, 2, TextureFormat.RGBA32, false);
+            texture.SetPixels(new[] { color, color, color, color });
+            texture.Apply();
+
+            var bytes = texture.EncodeToPNG();
+            UnityEngine.Object.DestroyImmediate(texture);
+
+            File.WriteAllBytes(ResolveProjectRelativePath(TempReimportTexturePath), bytes);
+            AssetDatabase.ImportAsset(
+                TempReimportTexturePath,
+                ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
+        }
+
         private static string ResolveProjectRelativePath(string assetPath)
         {
             var projectRoot = Path.GetDirectoryName(Application.dataPath);
@@ -1062,6 +1424,19 @@ namespace UCP.Bridge.Tests
             return null;
         }
 
+        private static Dictionary<string, object> FindAssetMatchByPath(List<object> matches, string expectedPath)
+        {
+            foreach (var entry in matches)
+            {
+                var match = (Dictionary<string, object>)entry;
+                var path = match.ContainsKey("path") ? match["path"].ToString() : string.Empty;
+                if (path == expectedPath)
+                    return match;
+            }
+
+            return null;
+        }
+
         private sealed class SearchRootAsset : ScriptableObject
         {
         }

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

@@ -1,6 +1,6 @@
 {
   "name": "com.ucp.bridge",
-  "version": "0.4.6",
+  "version": "0.5.1",
   "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,11 +1,11 @@
 {
   "name": "@mflrevan/ucp",
-  "version": "0.4.6",
+  "version": "0.5.1",
   "description": "Unity Control Protocol - CLI for programmatic Unity Editor control",
   "license": "MIT",
   "repository": {
     "type": "git",
-    "url": "https://github.com/mflRevan/unity-control-protocol.git"
+    "url": "git+https://github.com/mflRevan/unity-control-protocol.git"
   },
   "bin": {
     "ucp": "bin/ucp.js"