chore: Delete obsolete .windsurf/workflows/git-commits.md

CoderGamester · CoderGamester · commit 00b39442f66e · 2025-07-31T22:01:00.000+03:00
fix: Fix issue # reported on GitHub by allowing properties to be changed with UpdateComponent call
feat(tools): support GameObject selection by name, path, or instance ID. This improves flexibility for tool-driven GameObject selection in Unity.

- Update `selectGameObjectTool.ts` and C# counterpart to allow selecting GameObjects by instance ID, name, or hierarchical path.
- Refactor parameter schemas and validation logic to use `idOrName` for flexible identification.
- Update prompt and resource logic to match new selection method.
diff --git a/.windsurf/workflows/git-commits.md b/.windsurf/workflows/git-commits.md
diff --git a/Editor/Resources/GetGameObjectResource.cs b/Editor/Resources/GetGameObjectResource.cs
@@ -15,8 +15,8 @@ public class GetGameObjectResource : McpResourceBase
         public GetGameObjectResource()
         {
             Name = "get_gameobject";
-            Description = "Retrieves detailed information about a specific GameObject by instance ID";
-            Uri = "unity://gameobject/{id}";
+            Description = "Retrieves detailed information about a specific GameObject by instance ID or object name or path";
+            Uri = "unity://gameobject/{idOrName}";
         }
         
         /// <summary>
@@ -27,28 +27,39 @@ public GetGameObjectResource()
         public override JObject Fetch(JObject parameters)
         {
             // Validate parameters
-            if (parameters == null || !parameters.ContainsKey("objectPathId"))
+            if (parameters == null || !parameters.ContainsKey("idOrName"))
             {
                 return new JObject
                 {
                     ["success"] = false,
-                    ["message"] = "Missing required parameter: objectPathId"
+                    ["message"] = "Missing required parameter: idOrName"
+                };
+            }
+
+            string idOrName = parameters["idOrName"]?.ToObject<string>();
+            
+            if (string.IsNullOrEmpty(idOrName))
+            {
+                return new JObject
+                {
+                    ["success"] = false,
+                    ["message"] = "Parameter 'objectPathId' cannot be null or empty"
                 };
             }
 
-            string objectPathId = parameters["objectPathId"]?.ToObject<string>();
             GameObject gameObject = null;
             
             // Try to parse as an instance ID first
-            if (int.TryParse(objectPathId, out int instanceId))
+            if (int.TryParse(idOrName, out int instanceId))
             {
-                // If it's a valid integer, try to find by instance ID
-                gameObject = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
+                // Unity Instance IDs are typically negative, but we'll accept any integer
+                UnityEngine.Object unityObject = EditorUtility.InstanceIDToObject(instanceId);
+                gameObject = unityObject as GameObject;
             }
             else
             {
-                // Otherwise, treat it as a path
-                gameObject = GameObject.Find(objectPathId);
+                // Otherwise, treat it as a name or hierarchical path
+                gameObject = GameObject.Find(idOrName);
             }
             
             // Check if the GameObject was found
@@ -57,7 +68,7 @@ public override JObject Fetch(JObject parameters)
                 return new JObject
                 {
                     ["success"] = false,
-                    ["message"] = $"GameObject with path '{objectPathId}' not found"
+                    ["message"] = $"GameObject with '{idOrName}' reference not found. Make sure the GameObject exists and is loaded in the current scene(s)."
                 };
             }
 
@@ -69,7 +80,8 @@ public override JObject Fetch(JObject parameters)
             {
                 ["success"] = true,
                 ["message"] = $"Retrieved GameObject data for '{gameObject.name}'",
-                ["gameObject"] = gameObjectData
+                ["gameObject"] = gameObjectData,
+                ["instanceId"] = gameObject.GetInstanceID()
             };
         }
 
diff --git a/Editor/Tools/SelectGameObjectTool.cs b/Editor/Tools/SelectGameObjectTool.cs
@@ -16,7 +16,7 @@ public class SelectGameObjectTool : McpToolBase
         public SelectGameObjectTool()
         {
             Name = "select_gameobject";
-            Description = "Sets the selected GameObject in the Unity editor by path or instance ID";
+            Description = "Sets the selected GameObject in the Unity editor by path, name or instance ID";
         }
         
         /// <summary>
@@ -27,13 +27,14 @@ public override JObject Execute(JObject parameters)
         {
             // Extract parameters
             string objectPath = parameters["objectPath"]?.ToObject<string>();
+            string objectName = parameters["objectName"]?.ToObject<string>();
             int? instanceId = parameters["instanceId"]?.ToObject<int?>();
             
             // Validate parameters - require either objectPath or instanceId
-            if (string.IsNullOrEmpty(objectPath) && !instanceId.HasValue)
+            if (string.IsNullOrEmpty(objectPath) && string.IsNullOrEmpty(objectName) && !instanceId.HasValue)
             {
                 return McpUnitySocketHandler.CreateErrorResponse(
-                    "Required parameter 'objectPath' or 'instanceId' not provided", 
+                    "Required parameter 'objectPath', 'objectName' or 'instanceId' not provided", 
                     "validation_error"
                 );
             }
@@ -44,26 +45,29 @@ public override JObject Execute(JObject parameters)
                 Selection.activeGameObject = EditorUtility.InstanceIDToObject(instanceId.Value) as GameObject;
             }
             // Otherwise, try to find by object path/name if provided
-            else
+            else if (!string.IsNullOrEmpty(objectPath))
             {
                 // Try to find the object by path in the hierarchy
                 Selection.activeGameObject = GameObject.Find(objectPath);
             }
+            else if (!string.IsNullOrEmpty(objectName))
+            {
+                // Try to find the object by name in the hierarchy
+                Selection.activeGameObject = GameObject.Find(objectName);
+            }
 
             // Ping the selected object
             EditorGUIUtility.PingObject(Selection.activeGameObject);
             
             // Log the selection
-            McpLogger.LogInfo($"[MCP Unity] Selected GameObject: " +
-                (instanceId.HasValue ? $"Instance ID {instanceId.Value}" : $"Path '{objectPath}'"));
+            McpLogger.LogInfo($"[MCP Unity] Selected GameObject: {Selection.activeGameObject.name}"));
             
             // Create the response
             return new JObject
             {
                 ["success"] = true,
                 ["type"] = "text",
-                ["message"] = $"Successfully selected GameObject" + 
-                    (instanceId.HasValue ? $" with instance ID: {instanceId.Value}" : $": {objectPath}")
+                ["message"] = $"Successfully selected GameObject {Selection.activeGameObject.name}"
             };
         }
     }
diff --git a/Editor/Tools/UpdateComponentTool.cs b/Editor/Tools/UpdateComponentTool.cs
@@ -249,7 +249,7 @@ private bool UpdateComponentData(Component component, JObject componentData)
             // Record object for undo
             Undo.RecordObject(component, $"Update {componentType.Name} fields");
             
-            // Process each field in the component data
+            // Process each field or property in the component data
             foreach (var property in componentData.Properties())
             {
                 string fieldName = property.Name;
@@ -272,10 +272,21 @@ private bool UpdateComponentData(Component component, JObject componentData)
                     anySuccess = true;
                     continue;
                 }
-                else
+                
+                // Try to update property if not found as a field
+                PropertyInfo propertyInfo = componentType.GetProperty(fieldName, 
+                    BindingFlags.Public | BindingFlags.NonPublic | BindingFlags.Instance);
+                
+                if (propertyInfo != null)
                 {
-                    McpLogger.LogWarning($"Field '{fieldName}' not found on component '{componentType.Name}'");
+                    object value = ConvertJTokenToValue(fieldValue, propertyInfo.PropertyType);
+                    propertyInfo.SetValue(component, value);
+                    anySuccess = true;
+                    continue;
                 }
+                
+                // Try to update field
+                McpLogger.LogWarning($"Field or Property  with name '{fieldName}' not found on component '{componentType.Name}'");
             }
             
             return anySuccess;
diff --git a/Editor/Utils/McpUtils.cs b/Editor/Utils/McpUtils.cs
@@ -195,10 +195,7 @@ private static bool AddToConfigFile(string configFilePath, bool useTabsIndentati
                 // Check if the file exists
                 if (File.Exists(configFilePath))
                 {
-                    if (TryMergeMcpServers(configFilePath, mcpConfig, productName))
-                    {
-                        return true;
-                    }
+                    return TryMergeMcpServers(configFilePath, mcpConfig, productName);
                 }
                 else if(Directory.Exists(Path.GetDirectoryName(configFilePath)))
                 {
diff --git a/Server~/src/prompts/gameobjectHandlingPrompt.ts b/Server~/src/prompts/gameobjectHandlingPrompt.ts
@@ -12,27 +12,28 @@ export function registerGameObjectHandlingPrompt(server: McpServer) {
     'gameobject_handling_strategy',
     'Defines the proper workflow for handling gameobjects in Unity',
     {
-      gameObjectId: z.string().describe("The ID of the GameObject to handle. It can be the name of the GameObject or the path to the GameObject."),
+      gameObjectIdOrName: z.string().describe("The resource to identify the GameObject intended to handle. It can be the **instance ID**, the **name** or the **path** to the GameObject."),
     },
-    async ({ gameObjectId }) => ({
+    async ({ gameObjectIdOrName }) => ({
       messages: [
         {
           role: 'user', 
           content: {
             type: 'text',
             text: `You are an expert AI assistant integrated with Unity via MCP.
+
 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/{id}) to fetch detailed GameObject info, with the id being the name of the GameObject or the path to the GameObject.
-- Tool "select_gameobject" to select a GameObject by ID or path.
+- 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).
 
 Workflow:
-1. Use "get_scenes_hierarchy" to confirm the GameObject ID or path for "${gameObjectId}".
+1. Use "get_scenes_hierarchy" to confirm the GameObject ID, name or path for "${gameObjectIdOrName}".
 2. If you need to update the GameObject's core properties (name, tag, layer, active state, static state), or create the GameObject if it does not exist, use "update_gameobject".
 3. To focus the Unity Editor on the target GameObject, invoke "select_gameobject".
-4. Optionally, use "unity://gameobject/${gameObjectId}" to retrieve detailed properties.
+4. Optionally, use "unity://gameobject/${gameObjectIdOrName}" to retrieve detailed properties.
 5. To update or add a component on the GameObject, use "update_component".
 6. Confirm success and report any errors.
 
@@ -46,7 +47,7 @@ Guidance:
           role: 'user',
           content: {
             type: 'text',
-            text: `Handle GameObject "${gameObjectId}" through the above workflow.`
+            text: `Handle GameObject "${gameObjectIdOrName}" through the above workflow.`
           }
         }
       ]
diff --git a/Server~/src/resources/getGameObjectResource.ts b/Server~/src/resources/getGameObjectResource.ts
@@ -8,7 +8,7 @@ import { resourceName as hierarchyResourceName } from './getScenesHierarchyResou
 
 // Constants for the resource
 const resourceName = 'get_gameobject';
-const resourceUri = 'unity://gameobject/{id}';
+const resourceUri = 'unity://gameobject/{idOrName}';
 const resourceMimeType = 'application/json';
 
 /**
@@ -36,7 +36,7 @@ export function registerGetGameObjectResource(server: McpServer, mcpUnity: McpUn
     resourceName,
     resourceTemplate,
     {
-      description: 'Retrieve a GameObject by ID or path',
+      description: 'Retrieve a GameObject by instance ID, name, or hierarchical path (e.g., "Parent/Child/MyObject")',
       mimeType: resourceMimeType
     },
     async (uri, variables) => {
@@ -61,13 +61,13 @@ export function registerGetGameObjectResource(server: McpServer, mcpUnity: McpUn
  */
 async function resourceHandler(mcpUnity: McpUnity, uri: URL, variables: Variables, logger: Logger): Promise<ReadResourceResult> {
   // Extract and convert the parameter from the template variables
-  const id = decodeURIComponent(variables["id"] as string);
+  const idOrName = decodeURIComponent(variables["idOrName"] as string);
       
   // Send request to Unity
   const response = await mcpUnity.sendRequest({
     method: resourceName,
     params: {
-      objectPathId: id
+      idOrName: idOrName
     }
   });
   
@@ -80,7 +80,7 @@ async function resourceHandler(mcpUnity: McpUnity, uri: URL, variables: Variable
   
   return {
     contents: [{
-      uri: `unity://gameobject/${id}`,
+      uri: `unity://gameobject/${idOrName}`,
       mimeType: resourceMimeType,
       text: JSON.stringify(response, null, 2)
     }]
diff --git a/Server~/src/tools/selectGameObjectTool.ts b/Server~/src/tools/selectGameObjectTool.ts
@@ -7,9 +7,10 @@ import { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
 
 // Constants for the tool
 const toolName = 'select_gameobject';
-const toolDescription = 'Sets the selected GameObject in the Unity editor by path or instance ID';
+const toolDescription = 'Sets the selected GameObject in the Unity editor by path, name or instance ID';
 const paramsSchema = z.object({
   objectPath: z.string().optional().describe('The path or name of the GameObject to select (e.g. "Main Camera")'),
+  objectName: z.string().optional().describe('The name of the GameObject to select'),
   instanceId: z.number().optional().describe('The instance ID of the GameObject to select')
 });
 
@@ -53,10 +54,10 @@ export function registerSelectGameObjectTool(server: McpServer, mcpUnity: McpUni
  */
 async function toolHandler(mcpUnity: McpUnity, params: any): Promise<CallToolResult> {
   // Custom validation since we can't use refine/superRefine while maintaining ZodObject type
-  if (params.objectPath === undefined && params.instanceId === undefined) {
+  if (params.objectPath === undefined && params.objectName === undefined && params.instanceId === undefined) {
     throw new McpUnityError(
       ErrorType.VALIDATION,
-      "Either 'objectPath' or 'instanceId' must be provided"
+      "Either 'objectPath', 'objectName' or 'instanceId' must be provided"
     );
   }
   

Original file line number	Diff line number	Diff line change
`@@ -15,8 +15,8 @@ public class GetGameObjectResource : McpResourceBase`
`15`	`15`	`public GetGameObjectResource()`
`16`	`16`	`{`
`17`	`17`	`Name = "get_gameobject";`
`18`		`- Description = "Retrieves detailed information about a specific GameObject by instance ID";`
`19`		`- Uri = "unity://gameobject/{id}";`
	`18`	`+ Description = "Retrieves detailed information about a specific GameObject by instance ID or object name or path";`
	`19`	`+ Uri = "unity://gameobject/{idOrName}";`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`/// <summary>`
`@@ -27,28 +27,39 @@ public GetGameObjectResource()`
`27`	`27`	`public override JObject Fetch(JObject parameters)`
`28`	`28`	`{`
`29`	`29`	`// Validate parameters`
`30`		`- if (parameters == null \|\| !parameters.ContainsKey("objectPathId"))`
	`30`	`+ if (parameters == null \|\| !parameters.ContainsKey("idOrName"))`
`31`	`31`	`{`
`32`	`32`	`return new JObject`
`33`	`33`	`{`
`34`	`34`	`["success"] = false,`
`35`		`- ["message"] = "Missing required parameter: objectPathId"`
	`35`	`+ ["message"] = "Missing required parameter: idOrName"`
	`36`	`+ };`
	`37`	`+ }`
	`38`	`+`
	`39`	`+ string idOrName = parameters["idOrName"]?.ToObject<string>();`
	`40`	`+`
	`41`	`+ if (string.IsNullOrEmpty(idOrName))`
	`42`	`+ {`
	`43`	`+ return new JObject`
	`44`	`+ {`
	`45`	`+ ["success"] = false,`
	`46`	`+ ["message"] = "Parameter 'objectPathId' cannot be null or empty"`
`36`	`47`	`};`
`37`	`48`	`}`
`38`	`49`
`39`		`- string objectPathId = parameters["objectPathId"]?.ToObject<string>();`
`40`	`50`	`GameObject gameObject = null;`
`41`	`51`
`42`	`52`	`// Try to parse as an instance ID first`
`43`		`- if (int.TryParse(objectPathId, out int instanceId))`
	`53`	`+ if (int.TryParse(idOrName, out int instanceId))`
`44`	`54`	`{`
`45`		`- // If it's a valid integer, try to find by instance ID`
`46`		`- gameObject = EditorUtility.InstanceIDToObject(instanceId) as GameObject;`
	`55`	`+ // Unity Instance IDs are typically negative, but we'll accept any integer`
	`56`	`+ UnityEngine.Object unityObject = EditorUtility.InstanceIDToObject(instanceId);`
	`57`	`+ gameObject = unityObject as GameObject;`
`47`	`58`	`}`
`48`	`59`	`else`
`49`	`60`	`{`
`50`		`- // Otherwise, treat it as a path`
`51`		`- gameObject = GameObject.Find(objectPathId);`
	`61`	`+ // Otherwise, treat it as a name or hierarchical path`
	`62`	`+ gameObject = GameObject.Find(idOrName);`
`52`	`63`	`}`
`53`	`64`
`54`	`65`	`// Check if the GameObject was found`
`@@ -57,7 +68,7 @@ public override JObject Fetch(JObject parameters)`
`57`	`68`	`return new JObject`
`58`	`69`	`{`
`59`	`70`	`["success"] = false,`
`60`		`- ["message"] = $"GameObject with path '{objectPathId}' not found"`
	`71`	`+ ["message"] = $"GameObject with '{idOrName}' reference not found. Make sure the GameObject exists and is loaded in the current scene(s)."`
`61`	`72`	`};`
`62`	`73`	`}`
`63`	`74`
`@@ -69,7 +80,8 @@ public override JObject Fetch(JObject parameters)`
`69`	`80`	`{`
`70`	`81`	`["success"] = true,`
`71`	`82`	`["message"] = $"Retrieved GameObject data for '{gameObject.name}'",`
`72`		`- ["gameObject"] = gameObjectData`
	`83`	`+ ["gameObject"] = gameObjectData,`
	`84`	`+ ["instanceId"] = gameObject.GetInstanceID()`
`73`	`85`	`};`
`74`	`86`	`}`
`75`	`87`
Original file line number	Diff line number	Diff line change
`@@ -16,7 +16,7 @@ public class SelectGameObjectTool : McpToolBase`
`16`	`16`	`public SelectGameObjectTool()`
`17`	`17`	`{`
`18`	`18`	`Name = "select_gameobject";`
`19`		`- Description = "Sets the selected GameObject in the Unity editor by path or instance ID";`
	`19`	`+ Description = "Sets the selected GameObject in the Unity editor by path, name or instance ID";`
`20`	`20`	`}`
`21`	`21`
`22`	`22`	`/// <summary>`
`@@ -27,13 +27,14 @@ public override JObject Execute(JObject parameters)`
`27`	`27`	`{`
`28`	`28`	`// Extract parameters`
`29`	`29`	`string objectPath = parameters["objectPath"]?.ToObject<string>();`
	`30`	`+ string objectName = parameters["objectName"]?.ToObject<string>();`
`30`	`31`	`int? instanceId = parameters["instanceId"]?.ToObject<int?>();`
`31`	`32`
`32`	`33`	`// Validate parameters - require either objectPath or instanceId`
`33`		`- if (string.IsNullOrEmpty(objectPath) && !instanceId.HasValue)`
	`34`	`+ if (string.IsNullOrEmpty(objectPath) && string.IsNullOrEmpty(objectName) && !instanceId.HasValue)`
`34`	`35`	`{`
`35`	`36`	`return McpUnitySocketHandler.CreateErrorResponse(`
`36`		`- "Required parameter 'objectPath' or 'instanceId' not provided",`
	`37`	`+ "Required parameter 'objectPath', 'objectName' or 'instanceId' not provided",`
`37`	`38`	`"validation_error"`
`38`	`39`	`);`
`39`	`40`	`}`
`@@ -44,26 +45,29 @@ public override JObject Execute(JObject parameters)`
`44`	`45`	`Selection.activeGameObject = EditorUtility.InstanceIDToObject(instanceId.Value) as GameObject;`
`45`	`46`	`}`
`46`	`47`	`// Otherwise, try to find by object path/name if provided`
`47`		`- else`
	`48`	`+ else if (!string.IsNullOrEmpty(objectPath))`
`48`	`49`	`{`
`49`	`50`	`// Try to find the object by path in the hierarchy`
`50`	`51`	`Selection.activeGameObject = GameObject.Find(objectPath);`
`51`	`52`	`}`
	`53`	`+ else if (!string.IsNullOrEmpty(objectName))`
	`54`	`+ {`
	`55`	`+ // Try to find the object by name in the hierarchy`
	`56`	`+ Selection.activeGameObject = GameObject.Find(objectName);`
	`57`	`+ }`
`52`	`58`
`53`	`59`	`// Ping the selected object`
`54`	`60`	`EditorGUIUtility.PingObject(Selection.activeGameObject);`
`55`	`61`
`56`	`62`	`// Log the selection`
`57`		`- McpLogger.LogInfo($"[MCP Unity] Selected GameObject: " +`
`58`		`- (instanceId.HasValue ? $"Instance ID {instanceId.Value}" : $"Path '{objectPath}'"));`
	`63`	`+ McpLogger.LogInfo($"[MCP Unity] Selected GameObject: {Selection.activeGameObject.name}"));`
`59`	`64`
`60`	`65`	`// Create the response`
`61`	`66`	`return new JObject`
`62`	`67`	`{`
`63`	`68`	`["success"] = true,`
`64`	`69`	`["type"] = "text",`
`65`		`- ["message"] = $"Successfully selected GameObject" +`
`66`		`- (instanceId.HasValue ? $" with instance ID: {instanceId.Value}" : $": {objectPath}")`
	`70`	`+ ["message"] = $"Successfully selected GameObject {Selection.activeGameObject.name}"`
`67`	`71`	`};`
`68`	`72`	`}`
`69`	`73`	`}`
Original file line number	Diff line number	Diff line change
`@@ -195,10 +195,7 @@ private static bool AddToConfigFile(string configFilePath, bool useTabsIndentati`
`195`	`195`	`// Check if the file exists`
`196`	`196`	`if (File.Exists(configFilePath))`
`197`	`197`	`{`
`198`		`- if (TryMergeMcpServers(configFilePath, mcpConfig, productName))`
`199`		`- {`
`200`		`- return true;`
`201`		`- }`
	`198`	`+ return TryMergeMcpServers(configFilePath, mcpConfig, productName);`
`202`	`199`	`}`
`203`	`200`	`else if(Directory.Exists(Path.GetDirectoryName(configFilePath)))`
`204`	`201`	`{`