Move Get commands to editor resources + Run Python tests every update (#368)

* Add a function to reload the domain

Closes #357

* feat: restructure server instructions into workflow-focused format

- Reorganized instructions from flat bullet list into categorized workflow sections
- Emphasized critical script management workflow with numbered steps
- Improved readability and scannability for AI agents using the MCP server

It doesn't make sense to repeat the fucnction tools, they're already parsed

* docs: reorder tool list alphabetically in README + add reload_domain tool

* feat: add Unity editor state and project info resources

- Implemented resources for querying active tool, editor state, prefab stage, selection, and open windows
- Added project configuration resources for layers and project metadata
- Organized new resources into Editor and Project namespaces for better structure

* feat: clarify script management workflow in system prompt

- Expanded guidance to include scripts created by any tool, not just manage_script
- Added "etc" to tools examples for better clarity

* refactor: remove reload_domain tool and update script management workflow

- Removed reload_domain tool as Unity automatically recompiles scripts when modified
- Updated script management instructions to rely on editor_state polling and console checking instead of manual domain reload
- Simplified workflow by removing unnecessary manual recompilation step

* Change name of menu items resource as the LLM seems it

* refactor: reorganize tests into src/tests/integration directory

- Moved all test files from root tests/ to MCPForUnity/UnityMcpServer~/src/tests/integration/ for better organization
- Added conftest.py with telemetry and dependency stubs to simplify test setup
- Removed redundant path manipulation and module loading code from individual test files

* feat: expand Unity test workflow triggers

- Run tests on all branches instead of only main
- Add pull request trigger to catch issues before merge
- Maintain path filtering to run only when relevant files change

* chore: add GitHub Actions workflow for Python tests

- Configured automated testing on push and pull requests using pytest
- Set up uv for dependency management and Python 3.10 environment
- Added test results artifact upload for debugging failed runs

* refactor: update import path for fastmcp Context

* docs: update development setup instructions to use uv

- Changed installation commands from pip to uv pip for better dependency management
- Updated test running instructions to use uv run pytest
- Added examples for running integration and unit tests separately

* Formatting [skip ci]

* refactor: optimize CI workflow with path filters and dependency installation

- Added path filters to only trigger tests when Python source or workflow files change
- Split dependency installation into sync and dev install steps for better clarity
- Fixed YAML indentation for improved readability

* Update .github/workflows/python-tests.yml

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

* fix: standardize test mode values to match Unity's naming convention

- Changed default mode from "edit" to "EditMode" in C# code
- Updated Python tool to use "EditMode" and "PlayMode" instead of lowercase variants

* refactor: convert test imports to relative imports

- Changed absolute imports to relative imports in integration tests for better package structure
- Removed test packages from pyproject.toml package list

* refactor: use Field with default_factory for mutable default in TagsResponse

* refactor: remove duplicate PrefabStageUtility call

* Update this as well [skip ci]

* Update MCPForUnity/UnityMcpServer~/src/tests/integration/test_script_tools.py

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

* chore: remove pull_request triggers from test workflows [skip ci]

It's already covered by pushes

* refactor: update resource function return types to include MCPResponse union

* refactor: remove manual domain reload tool

- Removed reload_domain tool as Unity handles script recompilation automatically
- Updated documentation to reflect automatic compilation workflow
- Simplified script management workflow instructions in server description

* refactor: add context support to resource handlers

- Updated all resource handlers to accept Context parameter for Unity instance routing
- Replaced direct async_send_command_with_retry calls with async_send_with_unity_instance wrapper
- Added imports for get_unity_instance_from_context and async_send_with_unity_instance helpers

* fix: correct grammar in menu items documentation

* docs: update README with expanded tools and resources documentation

- Added new tools: manage_prefabs, create_script, delete_script, get_sha
- Added new resources: editor state, windows, project info, layers, and tags
- Clarified manage_script as compatibility router with recommendation to use newer edit tools
- Fixed run_test to run_tests for consistency

* refactor: convert unity_instances function to async [skip ci]

- Changed function signature from synchronous to async
- Added await keywords to ctx.info() and ctx.error() calls to properly handle async context methods

---------

Co-authored-by: coderabbitai[bot] <136622811+coderabbitai[bot]@users.noreply.github.com>

Author: msanatan

.github/workflows/python-tests.yml

@@ -0,0 +1,45 @@
+name: Python Tests
+
+on:
+  push:
+    branches: ["**"]
+    paths:
+      - MCPForUnity/UnityMcpServer~/src/**
+      - .github/workflows/python-tests.yml
+  workflow_dispatch: {}
+
+jobs:
+  test:
+    name: Run Python Tests
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Install uv
+        uses: astral-sh/setup-uv@v4
+        with:
+          version: "latest"
+
+      - name: Set up Python
+        run: uv python install 3.10
+
+      - name: Install dependencies
+        run: |
+          cd MCPForUnity/UnityMcpServer~/src
+          uv sync
+          uv pip install -e ".[dev]"
+
+      - name: Run tests
+        run: |
+          cd MCPForUnity/UnityMcpServer~/src
+          uv run pytest tests/ -v --tb=short
+
+      - name: Upload test results
+        uses: actions/upload-artifact@v4
+        if: always()
+        with:
+          name: pytest-results
+          path: |
+            MCPForUnity/UnityMcpServer~/src/.pytest_cache/
+            MCPForUnity/UnityMcpServer~/src/tests/

.github/workflows/unity-tests.yml

@@ -3,7 +3,7 @@ name: Unity Tests
 on:
   workflow_dispatch: {}
   push:
-    branches: [main]
+    branches: ["**"]
     paths:
       - TestProjects/UnityMCPTests/**
       - MCPForUnity/Editor/**

TestProjects/UnityMCPTests/Assets/Materials.meta renamed to MCPForUnity/Editor/Resources/Editor.meta

@@ -0,0 +1,64 @@
+using System;
+using MCPForUnity.Editor.Helpers;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+
+namespace MCPForUnity.Editor.Resources.Editor
+{
+    /// <summary>
+    /// Provides information about the currently active editor tool.
+    /// </summary>
+    [McpForUnityResource("get_active_tool")]
+    public static class ActiveTool
+    {
+        public static object HandleCommand(JObject @params)
+        {
+            try
+            {
+                Tool currentTool = UnityEditor.Tools.current;
+                string toolName = currentTool.ToString();
+                bool customToolActive = UnityEditor.Tools.current == Tool.Custom;
+                string activeToolName = customToolActive ? EditorTools.GetActiveToolName() : toolName;
+
+                var toolInfo = new
+                {
+                    activeTool = activeToolName,
+                    isCustom = customToolActive,
+                    pivotMode = UnityEditor.Tools.pivotMode.ToString(),
+                    pivotRotation = UnityEditor.Tools.pivotRotation.ToString(),
+                    handleRotation = new
+                    {
+                        x = UnityEditor.Tools.handleRotation.eulerAngles.x,
+                        y = UnityEditor.Tools.handleRotation.eulerAngles.y,
+                        z = UnityEditor.Tools.handleRotation.eulerAngles.z
+                    },
+                    handlePosition = new
+                    {
+                        x = UnityEditor.Tools.handlePosition.x,
+                        y = UnityEditor.Tools.handlePosition.y,
+                        z = UnityEditor.Tools.handlePosition.z
+                    }
+                };
+
+                return Response.Success("Retrieved active tool information.", toolInfo);
+            }
+            catch (Exception e)
+            {
+                return Response.Error($"Error getting active tool: {e.Message}");
+            }
+        }
+    }
+
+    // Helper class for custom tool names
+    internal static class EditorTools
+    {
+        public static string GetActiveToolName()
+        {
+            if (UnityEditor.Tools.current == Tool.Custom)
+            {
+                return "Unknown Custom Tool";
+            }
+            return UnityEditor.Tools.current.ToString();
+        }
+    }
+}

MCPForUnity/Editor/Resources/Editor/ActiveTool.cs

@@ -0,0 +1,40 @@
+using System;
+using MCPForUnity.Editor.Helpers;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+
+namespace MCPForUnity.Editor.Resources.Editor
+{
+    /// <summary>
+    /// Provides dynamic editor state information that changes frequently.
+    /// </summary>
+    [McpForUnityResource("get_editor_state")]
+    public static class EditorState
+    {
+        public static object HandleCommand(JObject @params)
+        {
+            try
+            {
+                var activeScene = EditorSceneManager.GetActiveScene();
+                var state = new
+                {
+                    isPlaying = EditorApplication.isPlaying,
+                    isPaused = EditorApplication.isPaused,
+                    isCompiling = EditorApplication.isCompiling,
+                    isUpdating = EditorApplication.isUpdating,
+                    timeSinceStartup = EditorApplication.timeSinceStartup,
+                    activeSceneName = activeScene.name ?? "",
+                    selectionCount = UnityEditor.Selection.count,
+                    activeObjectName = UnityEditor.Selection.activeObject?.name
+                };
+                
+                return Response.Success("Retrieved editor state.", state);
+            }
+            catch (Exception e)
+            {
+                return Response.Error($"Error getting editor state: {e.Message}");
+            }
+        }
+    }
+}

MCPForUnity/Editor/Resources/Editor/ActiveTool.cs.meta

@@ -0,0 +1,42 @@
+using System;
+using MCPForUnity.Editor.Helpers;
+using Newtonsoft.Json.Linq;
+using UnityEditor.SceneManagement;
+
+namespace MCPForUnity.Editor.Resources.Editor
+{
+    /// <summary>
+    /// Provides information about the current prefab editing context.
+    /// </summary>
+    [McpForUnityResource("get_prefab_stage")]
+    public static class PrefabStage
+    {
+        public static object HandleCommand(JObject @params)
+        {
+            try
+            {
+                var stage = PrefabStageUtility.GetCurrentPrefabStage();
+                
+                if (stage == null)
+                {
+                    return Response.Success("No prefab stage is currently open.", new { isOpen = false });
+                }
+
+                var stageInfo = new
+                {
+                    isOpen = true,
+                    assetPath = stage.assetPath,
+                    prefabRootName = stage.prefabContentsRoot?.name,
+                    mode = stage.mode.ToString(),
+                    isDirty = stage.scene.isDirty
+                };
+
+                return Response.Success("Prefab stage info retrieved.", stageInfo);
+            }
+            catch (Exception e)
+            {
+                return Response.Error($"Error getting prefab stage info: {e.Message}");
+            }
+        }
+    }
+}

MCPForUnity/Editor/Resources/Editor/EditorState.cs

@@ -0,0 +1,52 @@
+using System;
+using System.Linq;
+using MCPForUnity.Editor.Helpers;
+using Newtonsoft.Json.Linq;
+using UnityEditor;
+
+namespace MCPForUnity.Editor.Resources.Editor
+{
+    /// <summary>
+    /// Provides detailed information about the current editor selection.
+    /// </summary>
+    [McpForUnityResource("get_selection")]
+    public static class Selection
+    {
+        public static object HandleCommand(JObject @params)
+        {
+            try
+            {
+                var selectionInfo = new
+                {
+                    activeObject = UnityEditor.Selection.activeObject?.name,
+                    activeGameObject = UnityEditor.Selection.activeGameObject?.name,
+                    activeTransform = UnityEditor.Selection.activeTransform?.name,
+                    activeInstanceID = UnityEditor.Selection.activeInstanceID,
+                    count = UnityEditor.Selection.count,
+                    objects = UnityEditor.Selection.objects
+                        .Select(obj => new
+                        {
+                            name = obj?.name,
+                            type = obj?.GetType().FullName,
+                            instanceID = obj?.GetInstanceID()
+                        })
+                        .ToList(),
+                    gameObjects = UnityEditor.Selection.gameObjects
+                        .Select(go => new
+                        {
+                            name = go?.name,
+                            instanceID = go?.GetInstanceID()
+                        })
+                        .ToList(),
+                    assetGUIDs = UnityEditor.Selection.assetGUIDs
+                };
+
+                return Response.Success("Retrieved current selection details.", selectionInfo);
+            }
+            catch (Exception e)
+            {
+                return Response.Error($"Error getting selection: {e.Message}");
+            }
+        }
+    }
+}