Merge pull request #73 from CoderGamester/feature/create-prefab-tool

feat: Introduce CreatePrefabTool across Unity and Node pipelines

Author: CoderGamester

Editor/Tools/CreatePrefabTool.cs

@@ -0,0 +1,172 @@
+using System;
+using UnityEngine;
+using UnityEditor;
+using Newtonsoft.Json.Linq;
+using McpUnity.Unity;
+using McpUnity.Utils;
+
+namespace McpUnity.Tools
+{
+    /// <summary>
+    /// Tool for creating prefabs with optional MonoBehaviour scripts
+    /// </summary>
+    public class CreatePrefabTool : McpToolBase
+    {
+        public CreatePrefabTool()
+        {
+            Name = "create_prefab";
+            Description = "Creates a prefab with optional MonoBehaviour script and serialized field values";
+        }
+        
+        /// <summary>
+        /// Execute the CreatePrefab tool with the provided parameters
+        /// </summary>
+        /// <param name="parameters">Tool parameters as a JObject</param>
+        public override JObject Execute(JObject parameters)
+        {
+            // Extract parameters
+            string scriptName = parameters["scriptName"]?.ToObject<string>();
+            string prefabName = parameters["prefabName"]?.ToObject<string>();
+            JObject fieldValues = parameters["fieldValues"]?.ToObject<JObject>();
+            
+            // Validate required parameters
+            if (string.IsNullOrEmpty(prefabName))
+            {
+                return McpUnitySocketHandler.CreateErrorResponse(
+                    "Required parameter 'prefabName' not provided", 
+                    "validation_error"
+                );
+            }
+            
+            // Create a temporary GameObject
+            GameObject tempObject = new GameObject(prefabName);
+
+            // Add component if provided
+            if (!string.IsNullOrEmpty(scriptName))
+            {
+                try
+                {
+                    // Add component
+                    Component component = AddComponent(tempObject, scriptName);
+            
+                    // Apply field values if provided and component exists
+                    ApplyFieldValues(fieldValues, component);
+                }
+                catch (Exception ex)
+                {
+                    return McpUnitySocketHandler.CreateErrorResponse(
+                        $"Failed to add component '{scriptName}' to GameObject", 
+                        "component_error"
+                    );
+                }
+            }
+            
+            // For safety, we'll create a unique name if prefab already exists
+            int counter = 1;
+            string prefabPath = $"{prefabName}.prefab";
+            while (AssetDatabase.AssetPathToGUID(prefabPath) != "")
+            {
+                prefabPath = $"{prefabName}_{counter}.prefab";
+                counter++;
+            }
+            
+            // Create the prefab
+            GameObject prefab = PrefabUtility.SaveAsPrefabAsset(tempObject, prefabPath);
+            
+            // Clean up temporary object
+            UnityEngine.Object.DestroyImmediate(tempObject);
+            
+            // Refresh the asset database
+            AssetDatabase.Refresh();
+            
+            // Log the action
+            McpLogger.LogInfo($"Created prefab '{prefab.name}' at path '{prefabPath}' from script '{scriptName}'");
+            
+            // Create the response
+            return new JObject
+            {
+                ["success"] = true,
+                ["type"] = "text",
+                ["message"] = $"Successfully created prefab '{prefab.name}' at path '{prefabPath}'",
+                ["prefabPath"] = prefabPath
+            };
+        }
+
+        private Component AddComponent(GameObject gameObject, string scriptName)
+        {
+            // Find the script type
+            Type scriptType = Type.GetType($"{scriptName}, Assembly-CSharp");
+            if (scriptType == null)
+            {
+                // Try with just the class name
+                scriptType = Type.GetType(scriptName);
+            }
+                
+            if (scriptType == null)
+            {
+                // Try to find the type using AppDomain
+                foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+                {
+                    scriptType = assembly.GetType(scriptName);
+                    if (scriptType != null)
+                        break;
+                }
+            }
+                
+            // Throw an error if the type was not found
+            if (scriptType == null)
+            {
+                return null;
+            }
+                
+            // Check if the type is a MonoBehaviour
+            if (!typeof(MonoBehaviour).IsAssignableFrom(scriptType))
+            {
+                return null;
+            }
+            
+            return gameObject.AddComponent(scriptType);
+        }
+
+        private void ApplyFieldValues(JObject fieldValues, Component component)
+        {
+            // Apply field values if provided and component exists
+            if (fieldValues == null || fieldValues.Count == 0)
+            {
+                return;
+            }
+            
+            Undo.RecordObject(component, "Set field values");
+                
+            foreach (var property in fieldValues.Properties())
+            {
+                // Get the field/property info
+                var fieldInfo = component.GetType().GetField(property.Name, 
+                    System.Reflection.BindingFlags.Public | 
+                    System.Reflection.BindingFlags.NonPublic | 
+                    System.Reflection.BindingFlags.Instance);
+                            
+                if (fieldInfo != null)
+                {
+                    // Set field value
+                    object value = property.Value.ToObject(fieldInfo.FieldType);
+                    fieldInfo.SetValue(component, value);
+                }
+                else
+                {
+                    // Try property
+                    var propInfo = component.GetType().GetProperty(property.Name, 
+                        System.Reflection.BindingFlags.Public | 
+                        System.Reflection.BindingFlags.NonPublic | 
+                        System.Reflection.BindingFlags.Instance);
+                                
+                    if (propInfo != null && propInfo.CanWrite)
+                    {
+                        object value = property.Value.ToObject(propInfo.PropertyType);
+                        propInfo.SetValue(component, value);
+                    }
+                }
+            }
+        }
+    }
+}

Editor/Tools/CreatePrefabTool.cs.meta

@@ -249,6 +249,10 @@ private void RegisterTools()
             // Register AddAssetToSceneTool
             AddAssetToSceneTool addAssetToSceneTool = new AddAssetToSceneTool();
             _tools.Add(addAssetToSceneTool.Name, addAssetToSceneTool);
+            
+            // Register CreatePrefabTool
+            CreatePrefabTool createPrefabTool = new CreatePrefabTool();
+            _tools.Add(createPrefabTool.Name, createPrefabTool);
         }
 
         /// <summary>

Editor/UnityBridge/McpUnityServer.cs

@@ -83,6 +83,9 @@ MCP Unityは、Unityの`Library/PackedCache`フォルダーをワークスペー
 - `add_asset_to_scene`: AssetDatabaseからアセットをUnityシーンに追加
   > **例:** "プロジェクトからPlayerプレハブを現在のシーンに追加"
 
+- `create_prefab`: プレハブを作成し、オプションでMonoBehaviourスクリプトとシリアライズされたフィールド値を設定
+  > **例:** "'PlayerController'スクリプトから'Player'という名前のプレハブを作成"
+
 ### MCPサーバーリソース
 
 - `unity://menu-items`: `execute_menu_item`ツールを容易にするために、Unityエディターで利用可能なすべてのメニュー項目のリストを取得

README-ja.md

@@ -85,6 +85,9 @@ The following tools are available for manipulating and querying Unity scenes and
 - `add_asset_to_scene`: Adds an asset from the AssetDatabase to the Unity scene
   > **Example prompt:** "Add the Player prefab from my project to the current scene"
 
+- `create_prefab`: Creates a prefab with optional MonoBehaviour script and serialized field values
+  > **Example prompt:** "Create a prefab named 'Player' from the 'PlayerController' script"
+
 ### MCP Server Resources
 
 - `unity://menu-items`: Retrieves a list of all available menu items in the Unity Editor to facilitate `execute_menu_item` tool

README.md

@@ -84,6 +84,9 @@ MCP Unity 通过将 Unity `Library/PackedCache` 文件夹添加到您的工作
 - `add_asset_to_scene`: 将 AssetDatabase 中的资源添加到 Unity 场景中
   > **示例提示:** "将我的项目中的 Player 预制体添加到当前场景"
 
+- `create_prefab`: 创建预制体，并可选择添加 MonoBehaviour 脚本和设置序列化字段值
+  > **示例提示:** "从 'PlayerController' 脚本创建一个名为 'Player' 的预制体"
+
 ### MCP 服务器资源
 
 - `unity://menu-items`: 获取 Unity 编辑器中所有可用的菜单项列表，以方便 `execute_menu_item` 工具

README_zh-CN.md

@@ -12,6 +12,7 @@ import { registerGetConsoleLogsTool } from './tools/getConsoleLogsTool.js';
 import { registerUpdateComponentTool } from './tools/updateComponentTool.js';
 import { registerAddAssetToSceneTool } from './tools/addAssetToSceneTool.js';
 import { registerUpdateGameObjectTool } from './tools/updateGameObjectTool.js';
+import { registerCreatePrefabTool } from './tools/createPrefabTool.js';
 import { registerGetMenuItemsResource } from './resources/getMenuItemResource.js';
 import { registerGetConsoleLogsResource } from './resources/getConsoleLogsResource.js';
 import { registerGetHierarchyResource } from './resources/getScenesHierarchyResource.js';
@@ -55,6 +56,7 @@ registerGetConsoleLogsTool(server, mcpUnity, toolLogger);
 registerUpdateComponentTool(server, mcpUnity, toolLogger);
 registerAddAssetToSceneTool(server, mcpUnity, toolLogger);
 registerUpdateGameObjectTool(server, mcpUnity, toolLogger);
+registerCreatePrefabTool(server, mcpUnity, toolLogger);
 
 // Register all resources into the MCP server
 registerGetTestsResource(server, mcpUnity, resourceLogger);

Server~/src/index.ts

@@ -20,14 +20,15 @@ export function registerGameObjectHandlingPrompt(server: McpServer) {
           role: 'user', 
           content: {
             type: 'text',
-            text: `You are an expert AI assistant integrated with Unity via MCP.
+            text: `You are an expert AI assistant integrated with Unity via a MCP server.
 
 When working directly with GameObjects or any of their components in Unity scenes, you have access to the following resources and tools:
 - Resource "get_scenes_hierarchy" (unity://scenes_hierarchy) to list all GameObjects.
 - Resource "get_gameobject" (unity://gameobject/{idOrName}) to fetch detailed GameObject info, with the *idOrName* being either the **instance ID**, the **name** or the **path** to the GameObject.
 - Tool "select_gameobject" to select a GameObject by **instance ID**, the **name** or the **path** of the GameObject.
 - Tool "update_gameobject" to update a GameObject's core properties (name, tag, layer, active state, static state), or create the GameObject if it does not exist.
 - Tool "update_component" to update or add a component on a GameObject, including common frequently used components (e.g. Transform, RectTransform, BoxCollider, Rigidbody, etc).
+- Tool "create_prefab" to create a prefab from a GameObject in the scene with optional MonoBehaviour script and serialized field values.
 
 Workflow:
 1. Use "get_scenes_hierarchy" to confirm the GameObject ID, name or path for "${gameObjectIdOrName}".
@@ -38,8 +39,10 @@ Workflow:
 6. Confirm success and report any errors.
 
 Guidance:
-- Use "update_gameobject" for creating GameObjects or changing their core properties.
-- Use "update_component" for adding or modifying components on an existing GameObject.
+- Use "update_gameobject" for creating GameObjects in the scene or to change a GameObject's core properties.
+- Use "update_component" for adding or modifying components on an existing GameObject in the scene.
+- Use "create_prefab" for creating prefabs from GameObjects in the scene.
+- Component Scripts must be compiled in the Unity project before using "update_component" or "create_prefab".
 - Always validate inputs and request clarification if the identifier is ambiguous.`
           }
         },

Server~/src/prompts/gameobjectHandlingPrompt.ts

@@ -0,0 +1,91 @@
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { McpUnity } from '../unity/mcpUnity.js';
+import { McpUnityError, ErrorType } from '../utils/errors.js';
+import * as z from 'zod';
+import { Logger } from '../utils/logger.js';
+
+// Constants for the tool
+const toolName = 'create_prefab';
+const toolDescription = 'Creates a prefab with optional MonoBehaviour script and serialized field values';
+
+// Parameter schema for the tool
+const paramsSchema = z.object({
+  componentName: z.string().optional().describe('The name of the MonoBehaviour Component to add to the prefab (optional)'),
+  prefabName: z.string().describe('The name of the prefab to create'),
+  fieldValues: z.record(z.any()).optional().describe('Optional JSON object of serialized field values to apply to the prefab')
+});
+
+/**
+ * Creates and registers the CreatePrefab tool with the MCP server
+ * 
+ * @param server The MCP server to register the tool with
+ * @param mcpUnity The McpUnity instance to communicate with Unity
+ * @param logger The logger instance for diagnostic information
+ */
+export function registerCreatePrefabTool(server: McpServer, mcpUnity: McpUnity, logger: Logger) {
+  logger.info(`Registering tool: ${toolName}`);
+  
+  server.tool(
+    toolName,
+    toolDescription,
+    paramsSchema.shape,
+    async (params: any) => {
+      try {
+        logger.info(`Executing tool: ${toolName}`, params);
+        const result = await toolHandler(mcpUnity, params);
+        logger.info(`Tool execution successful: ${toolName}`);
+        return result;
+      } catch (error) {
+        logger.error(`Tool execution failed: ${toolName}`, error);
+        throw error;
+      }
+    }
+  );
+}
+
+/**
+ * Handler function for the CreatePrefab tool
+ * 
+ * @param mcpUnity The McpUnity instance to communicate with Unity
+ * @param params The validated parameters for the tool
+ * @returns A promise that resolves to the tool execution result
+ * @throws McpUnityError if validation fails or the request to Unity fails
+ */
+async function toolHandler(mcpUnity: McpUnity, params: any) {  
+  if (!params.scriptName) {
+    throw new McpUnityError(
+      ErrorType.VALIDATION,
+      "'scriptName' must be provided"
+    );
+  }
+  
+  if (!params.prefabName) {
+    throw new McpUnityError(
+      ErrorType.VALIDATION,
+      "'prefabName' must be provided"
+    );
+  }
+  
+  const response = await mcpUnity.sendRequest({
+    method: toolName,
+    params
+  });
+  
+  if (!response.success) {
+    throw new McpUnityError(
+      ErrorType.TOOL_EXECUTION,
+      response.message || `Failed to create prefab`
+    );
+  }
+  
+  return {
+    content: [{
+      type: response.type,
+      text: response.message || `Successfully created prefab`
+    }],
+    // Include the prefab path in the result for programmatic access
+    data: {
+      prefabPath: response.prefabPath
+    }
+  };
+}