feat: update prefab management commands to use 'prefabPath' and add 'create_from_gameobject' action

Author: msanatan

TestProjects/UnityMCPTests/Assets/Tests/EditMode/Tools/ManagePrefabsTests.cs

@@ -46,7 +46,7 @@ public void OpenStage_OpensPrefabInIsolation()
                 var openParams = new JObject
                 {
                     ["action"] = "open_stage",
-                    ["path"] = prefabPath
+                    ["prefabPath"] = prefabPath
                 };
 
                 var openResult = ToJObject(ManagePrefabs.HandleCommand(openParams));
@@ -94,7 +94,7 @@ public void CloseStage_ClosesOpenPrefabStage()
                 ManagePrefabs.HandleCommand(new JObject
                 {
                     ["action"] = "open_stage",
-                    ["path"] = prefabPath
+                    ["prefabPath"] = prefabPath
                 });
 
                 var closeResult = ToJObject(ManagePrefabs.HandleCommand(new JObject
@@ -122,7 +122,7 @@ public void SaveOpenStage_SavesDirtyChanges()
                 ManagePrefabs.HandleCommand(new JObject
                 {
                     ["action"] = "open_stage",
-                    ["path"] = prefabPath
+                    ["prefabPath"] = prefabPath
                 });
 
                 PrefabStage stage = PrefabStageUtility.GetCurrentPrefabStage();
@@ -162,62 +162,60 @@ public void SaveOpenStage_ReturnsError_WhenNoStageOpen()
         }
 
         [Test]
-        public void ApplyInstanceOverrides_UpdatesPrefabAsset()
+        public void CreateFromGameObject_CreatesPrefabAndLinksInstance()
         {
-            string prefabPath = CreateTestPrefab("ApplyOverridesCube");
-            GameObject prefabAsset = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
+            EnsureTempDirectoryExists();
+            StageUtility.GoToMainStage();
 
-            GameObject instance = (GameObject)PrefabUtility.InstantiatePrefab(prefabAsset);
-            instance.name = "ApplyOverridesInstance";
+            string prefabPath = Path.Combine(TempDirectory, "SceneObjectSaved.prefab").Replace('\\', '/');
+            GameObject sceneObject = new GameObject("ScenePrefabSource");
 
             try
             {
-                instance.transform.localScale = new Vector3(3f, 3f, 3f);
-
-                var applyResult = ToJObject(ManagePrefabs.HandleCommand(new JObject
+                var result = ToJObject(ManagePrefabs.HandleCommand(new JObject
                 {
-                    ["action"] = "apply_instance_overrides",
-                    ["instanceId"] = instance.GetInstanceID()
+                    ["action"] = "create_from_gameobject",
+                    ["target"] = sceneObject.name,
+                    ["prefabPath"] = prefabPath
                 }));
 
-                Assert.IsTrue(applyResult.Value<bool>("success"), "apply_instance_overrides should succeed for prefab instance.");
+                Assert.IsTrue(result.Value<bool>("success"), "create_from_gameobject should succeed for a valid scene object.");
 
-                GameObject reloaded = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
-                Assert.AreEqual(new Vector3(3f, 3f, 3f), reloaded.transform.localScale, "Prefab asset should reflect applied overrides.");
-            }
-            finally
-            {
-                UnityEngine.Object.DestroyImmediate(instance);
-                AssetDatabase.DeleteAsset(prefabPath);
-            }
-        }
+                var data = result["data"] as JObject;
+                Assert.IsNotNull(data, "Response data should include prefab information.");
 
-        [Test]
-        public void RevertInstanceOverrides_RevertsToPrefabDefaults()
-        {
-            string prefabPath = CreateTestPrefab("RevertOverridesCube");
-            GameObject prefabAsset = AssetDatabase.LoadAssetAtPath<GameObject>(prefabPath);
+                string savedPath = data.Value<string>("prefabPath");
+                Assert.AreEqual(prefabPath, savedPath, "Returned prefab path should match the requested path.");
 
-            GameObject instance = (GameObject)PrefabUtility.InstantiatePrefab(prefabAsset);
-            instance.name = "RevertOverridesInstance";
+                GameObject prefabAsset = AssetDatabase.LoadAssetAtPath<GameObject>(savedPath);
+                Assert.IsNotNull(prefabAsset, "Prefab asset should exist at the saved path.");
 
-            try
-            {
-                instance.transform.localScale = new Vector3(4f, 4f, 4f);
-
-                var revertResult = ToJObject(ManagePrefabs.HandleCommand(new JObject
-                {
-                    ["action"] = "revert_instance_overrides",
-                    ["instanceId"] = instance.GetInstanceID()
-                }));
+                int instanceId = data.Value<int>("instanceId");
+                var linkedInstance = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
+                Assert.IsNotNull(linkedInstance, "Linked instance should resolve from instanceId.");
+                Assert.AreEqual(savedPath, PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(linkedInstance), "Instance should be connected to the new prefab.");
 
-                Assert.IsTrue(revertResult.Value<bool>("success"), "revert_instance_overrides should succeed for prefab instance.");
-                Assert.AreEqual(Vector3.one, instance.transform.localScale, "Prefab instance should revert to default scale.");
+                sceneObject = linkedInstance;
             }
             finally
             {
-                UnityEngine.Object.DestroyImmediate(instance);
-                AssetDatabase.DeleteAsset(prefabPath);
+                if (AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(prefabPath) != null)
+                {
+                    AssetDatabase.DeleteAsset(prefabPath);
+                }
+
+                if (sceneObject != null)
+                {
+                    if (PrefabUtility.IsPartOfPrefabInstance(sceneObject))
+                    {
+                        PrefabUtility.UnpackPrefabInstance(
+                            sceneObject,
+                            PrefabUnpackMode.Completely,
+                            InteractionMode.AutomatedAction
+                        );
+                    }
+                    UnityEngine.Object.DestroyImmediate(sceneObject, true);
+                }
             }
         }
 

UnityMcpBridge/Editor/Tools/Prefabs/ManagePrefabs.cs

@@ -1,15 +1,17 @@
 using System;
+using System.IO;
 using MCPForUnity.Editor.Helpers;
 using Newtonsoft.Json.Linq;
 using UnityEditor;
 using UnityEditor.SceneManagement;
 using UnityEngine;
+using UnityEngine.SceneManagement;
 
 namespace MCPForUnity.Editor.Tools.Prefabs
 {
     public static class ManagePrefabs
     {
-        private const string SupportedActions = "open_stage, close_stage, save_open_stage, apply_instance_overrides, revert_instance_overrides";
+        private const string SupportedActions = "open_stage, close_stage, save_open_stage, create_from_gameobject";
 
         public static object HandleCommand(JObject @params)
         {
@@ -34,10 +36,8 @@ public static object HandleCommand(JObject @params)
                         return CloseStage(@params);
                     case "save_open_stage":
                         return SaveOpenStage();
-                    case "apply_instance_overrides":
-                        return ApplyInstanceOverrides(@params);
-                    case "revert_instance_overrides":
-                        return RevertInstanceOverrides(@params);
+                    case "create_from_gameobject":
+                        return CreatePrefabFromGameObject(@params);
                     default:
                         return Response.Error($"Unknown action: '{action}'. Valid actions are: {SupportedActions}.");
                 }
@@ -51,13 +51,13 @@ public static object HandleCommand(JObject @params)
 
         private static object OpenStage(JObject @params)
         {
-            string path = @params["path"]?.ToString();
-            if (string.IsNullOrEmpty(path))
+            string prefabPath = @params["prefabPath"]?.ToString();
+            if (string.IsNullOrEmpty(prefabPath))
             {
                 return Response.Error("'path' parameter is required for open_stage.");
             }
 
-            string sanitizedPath = AssetPathUtility.SanitizeAssetPath(path);
+            string sanitizedPath = AssetPathUtility.SanitizeAssetPath(prefabPath);
             GameObject prefabAsset = AssetDatabase.LoadAssetAtPath<GameObject>(sanitizedPath);
             if (prefabAsset == null)
             {
@@ -125,119 +125,120 @@ private static void SaveStagePrefab(PrefabStage stage)
             }
         }
 
-        private static object ApplyInstanceOverrides(JObject @params)
+        private static object CreatePrefabFromGameObject(JObject @params)
         {
-            if (!TryGetPrefabInstance(@params, out GameObject instanceRoot, out string error))
+            string targetName = @params["target"]?.ToString() ?? @params["name"]?.ToString();
+            if (string.IsNullOrEmpty(targetName))
             {
-                return Response.Error(error);
+                return Response.Error("'target' parameter is required for create_from_gameobject.");
             }
 
-            PrefabUtility.ApplyPrefabInstance(instanceRoot, InteractionMode.AutomatedAction);
-            string prefabAssetPath = PrefabUtility.GetPrefabAssetPathOfNearestInstanceRoot(instanceRoot);
+            bool includeInactive = @params["searchInactive"]?.ToObject<bool>() ?? false;
+            GameObject sourceObject = FindSceneObjectByName(targetName, includeInactive);
+            if (sourceObject == null)
+            {
+                return Response.Error($"GameObject '{targetName}' not found in the active scene.");
+            }
 
-            return Response.Success(
-                $"Applied overrides on prefab instance '{instanceRoot.name}'.",
-                new
-                {
-                    prefabAssetPath,
-                    instanceId = instanceRoot.GetInstanceID()
-                }
-            );
-        }
+            if (PrefabUtility.IsPartOfPrefabAsset(sourceObject))
+            {
+                return Response.Error(
+                    $"GameObject '{sourceObject.name}' is part of a prefab asset. Open the prefab stage to save changes instead."
+                );
+            }
 
-        private static object RevertInstanceOverrides(JObject @params)
-        {
-            if (!TryGetPrefabInstance(@params, out GameObject instanceRoot, out string error))
+            PrefabInstanceStatus status = PrefabUtility.GetPrefabInstanceStatus(sourceObject);
+            if (status != PrefabInstanceStatus.NotAPrefab)
             {
-                return Response.Error(error);
+                return Response.Error(
+                    $"GameObject '{sourceObject.name}' is already linked to an existing prefab instance."
+                );
             }
 
-            PrefabUtility.RevertPrefabInstance(instanceRoot, InteractionMode.AutomatedAction);
+            string requestedPath = @params["prefabPath"]?.ToString() ?? @params["path"]?.ToString();
+            if (string.IsNullOrWhiteSpace(requestedPath))
+            {
+                return Response.Error("'prefabPath' (or 'path') parameter is required for create_from_gameobject.");
+            }
 
-            return Response.Success(
-                $"Reverted overrides on prefab instance '{instanceRoot.name}'.",
-                new
-                {
-                    instanceId = instanceRoot.GetInstanceID()
-                }
-            );
-        }
+            string sanitizedPath = AssetPathUtility.SanitizeAssetPath(requestedPath);
+            if (!sanitizedPath.EndsWith(".prefab", StringComparison.OrdinalIgnoreCase))
+            {
+                sanitizedPath += ".prefab";
+            }
 
-        private static bool TryGetPrefabInstance(JObject @params, out GameObject instanceRoot, out string error)
-        {
-            instanceRoot = null;
-            error = null;
+            bool allowOverwrite = @params["allowOverwrite"]?.ToObject<bool>() ?? false;
+            string finalPath = sanitizedPath;
 
-            JToken instanceIdToken = @params["instanceId"] ?? @params["instanceID"];
-            if (instanceIdToken != null && instanceIdToken.Type == JTokenType.Integer)
+            if (!allowOverwrite && AssetDatabase.LoadAssetAtPath<UnityEngine.Object>(finalPath) != null)
             {
-                int instanceId = instanceIdToken.Value<int>();
-                if (!TryResolveInstance(instanceId, out instanceRoot, out error))
-                {
-                    return false;
-                }
-                return true;
+                finalPath = AssetDatabase.GenerateUniqueAssetPath(finalPath);
             }
 
-            string targetName = @params["target"]?.ToString();
-            if (!string.IsNullOrEmpty(targetName))
+            EnsureAssetDirectoryExists(finalPath);
+
+            try
             {
-                GameObject target = GameObject.Find(targetName);
-                if (target == null)
+                GameObject connectedInstance = PrefabUtility.SaveAsPrefabAssetAndConnect(
+                    sourceObject,
+                    finalPath,
+                    InteractionMode.AutomatedAction
+                );
+
+                if (connectedInstance == null)
                 {
-                    error = $"GameObject '{targetName}' not found in the current scene.";
-                    return false;
+                    return Response.Error($"Failed to save prefab asset at '{finalPath}'.");
                 }
 
-                instanceRoot = GetPrefabInstanceRoot(target, out error);
-                return instanceRoot != null;
-            }
-
-            error = "Parameter 'instanceId' (or 'target') is required for this action.";
-            return false;
-        }
-
-        private static bool TryResolveInstance(int instanceId, out GameObject instanceRoot, out string error)
-        {
-            instanceRoot = null;
-            error = null;
+                Selection.activeGameObject = connectedInstance;
 
-            GameObject obj = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
-            if (obj == null)
+                return Response.Success(
+                    $"Prefab created at '{finalPath}' and instance linked.",
+                    new
+                    {
+                        prefabPath = finalPath,
+                        instanceId = connectedInstance.GetInstanceID()
+                    }
+                );
+            }
+            catch (Exception e)
             {
-                error = $"No GameObject found for instanceId {instanceId}.";
-                return false;
+                return Response.Error($"Error saving prefab asset at '{finalPath}': {e.Message}");
             }
-
-            instanceRoot = GetPrefabInstanceRoot(obj, out error);
-            return instanceRoot != null;
         }
 
-        private static GameObject GetPrefabInstanceRoot(GameObject obj, out string error)
+        private static void EnsureAssetDirectoryExists(string assetPath)
         {
-            error = null;
-
-            if (!PrefabUtility.IsPartOfPrefabInstance(obj))
+            string directory = Path.GetDirectoryName(assetPath);
+            if (string.IsNullOrEmpty(directory))
             {
-                error = $"GameObject '{obj.name}' is not part of a prefab instance.";
-                return null;
+                return;
             }
 
-            GameObject root = PrefabUtility.GetOutermostPrefabInstanceRoot(obj);
-            if (root == null)
+            string fullDirectory = Path.Combine(Directory.GetCurrentDirectory(), directory);
+            if (!Directory.Exists(fullDirectory))
             {
-                error = $"Failed to resolve prefab instance root for '{obj.name}'.";
-                return null;
+                Directory.CreateDirectory(fullDirectory);
+                AssetDatabase.Refresh();
             }
+        }
 
-            PrefabInstanceStatus status = PrefabUtility.GetPrefabInstanceStatus(root);
-            if (status == PrefabInstanceStatus.NotAPrefab)
+        private static GameObject FindSceneObjectByName(string name, bool includeInactive)
+        {
+            Scene activeScene = SceneManager.GetActiveScene();
+            foreach (GameObject root in activeScene.GetRootGameObjects())
             {
-                error = $"GameObject '{obj.name}' is not recognised as a prefab instance.";
-                return null;
+                foreach (Transform transform in root.GetComponentsInChildren<Transform>(includeInactive))
+                {
+                    GameObject candidate = transform.gameObject;
+                    if (candidate.name == name)
+                    {
+                        return candidate;
+                    }
+                }
             }
 
-            return root;
+            return null;
         }
 
         private static object SerializeStage(PrefabStage stage)