Merge pull request #1224 from CoplayDev/release/v10.0.0

chore: bump version to 10.0.0

Author: github-actions[bot]

.claude/skills/blender-to-unity/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: blender-to-unity
+description: Hand off a model from Blender (via BlenderMCP) into Unity (via MCP for Unity) — export the current Blender model, import it through import_model_file, and place it in the open scene. Use when the user has BlenderMCP and MCP for Unity both connected and wants to bring a Blender model into Unity. Does NOT drive Blender's own generators; BlenderMCP owns how the model got into Blender.
+---
+
+# Blender → Unity Model Handoff
+
+Bring whatever model is currently in Blender into the open Unity scene. The seam is the
+local filesystem: Blender exports a file, Unity imports it. The two servers never talk
+directly.
+
+## Preconditions
+- Both `mcp__blender__*` tools and MCP for Unity tools are connected.
+- A model exists in the Blender scene (confirm with `mcp__blender__get_scene_info` /
+  `mcp__blender__get_object_info`). If empty, stop and tell the user — this skill does not generate models.
+
+## Steps
+1. **Resolve the Unity project path.** Read `mcpforunity://editor/state` for the project
+   root (the editor dataPath's parent). Decide the export format: **FBX by default**
+   (built-in importer, zero extra dependencies). Use glTF/.glb only if glTFast is installed
+   and PBR fidelity matters.
+2. **Export from Blender to a temp path** via `mcp__blender__execute_blender_code`:
+   ```python
+   import bpy, os, tempfile
+   out = os.path.join(tempfile.gettempdir(), "blender_to_unity.fbx")
+   # Export the selection if any, else the whole scene:
+   bpy.ops.export_scene.fbx(filepath=out, use_selection=bool(bpy.context.selected_objects),
+                            apply_unit_scale=True, bake_space_transform=True)
+   print(out)
+   ```
+   (glTF branch: `bpy.ops.export_scene.gltf(filepath=out_glb, export_format='GLB')`.)
+3. **Import into Unity** with `import_model_file`:
+   `import_model_file(source_path=<temp path>, name=<asset name>, target_size=<final size in meters>)`.
+   It returns `{ asset_path, asset_guid }`. Pass `target_size` as the intended final size, but treat
+   it only as a hint: it rescales at import solely when the project's **Auto-normalize** pref is on,
+   and even then is unreliable for Blender FBX (see the **Scale** note). Step 4 does the reliable
+   normalization.
+4. **Place it in the scene, normalized to size.** Ensure the scene has a camera + directional
+   light (`manage_scene` / `manage_gameobject`). Instantiate the model at the chosen position via
+   `manage_gameobject(action="create", prefab_path=<asset_path>, name=<asset name>, position=[x,y,z])`.
+   Then normalize its size deterministically — Blender FBX commonly imports ~100× too large — by
+   measuring the placed model's world bounds and scaling so its largest dimension equals your target
+   size. Run via `execute_code` (substitute your object name and target meters):
+   ```csharp
+   var go = GameObject.Find("<asset name>");
+   var rs = go.GetComponentsInChildren<Renderer>();
+   var b = rs[0].bounds; for (int i = 1; i < rs.Length; i++) b.Encapsulate(rs[i].bounds);
+   float maxDim = Mathf.Max(b.size.x, Mathf.Max(b.size.y, b.size.z));
+   float target = 2f; // intended size in meters
+   if (maxDim > 0.0001f) go.transform.localScale *= target / maxDim;
+   ```
+5. **Verify** with `manage_camera(action="screenshot", include_image=true)` and report the
+   asset path + a screenshot.
+
+## Notes
+- **Scale.** Models from Blender almost always arrive at the wrong scale — its FBX unit handling
+  makes them land ~100× too large in Unity. `import_model_file`'s `target_size` only rescales at
+  import when the project's Auto-normalize pref is enabled, and its importer-level normalization is
+  unreliable for Blender FBX (it can over- or under-shoot, e.g. a `target_size=2` model measured 200 m).
+  The robust fix is the Step 4 measure-bounds-then-set-`localScale` routine, which hits the target
+  size deterministically regardless of the import scale or the Auto-normalize pref.
+- FBX is the default because glTFast is optional in MCP for Unity. If the import errors with
+  "GLB import requires glTFast", re-export as FBX (or install glTFast from the Dependencies tab).
+- Keep one model per handoff; for batches, repeat the loop with distinct names.
+- This skill never sends API keys or file bytes over the MCP bridge — Unity reads the file from disk.
+- `import_model_file` copies only the single source file; for multi-file exports (a text `.gltf` with an external `.bin`, or an `.obj` with a sibling `.mtl`/textures), zip them first and pass the `.zip` — a bare `.gltf`/`.obj` will lose its sidecars.

.claude/skills/blender-to-unity/manual-verify.md

@@ -0,0 +1,14 @@
+# Manual Verify — blender-to-unity
+
+Run against a live Blender (BlenderMCP) + Unity (MCP for Unity) pair.
+
+- [ ] A cube/model exists in Blender (`get_scene_info` shows it).
+- [ ] FBX export writes a non-empty file to the temp path (printed path exists, size > 0).
+- [ ] `import_model_file` returns `success: true` with `asset_path` under `Assets/` and a non-empty `asset_guid`.
+- [ ] The imported model appears in the Project window at `asset_path`.
+- [ ] The model is instantiated in the open scene and visible in a `manage_camera` screenshot.
+- [ ] Scale: after the Step 4 measure-bounds-then-`localScale` routine, the placed model's largest
+      world dimension ≈ the target size (Blender FBX imports ~100× too large until normalized).
+- [ ] glTF path: with glTFast installed, a `.glb` export imports successfully; without it,
+      the error names glTFast/the Dependencies tab (and FBX still works).
+- [ ] No API keys or file bytes appear in any bridge payload (handoff is filesystem-only).

.github/workflows/docs-deploy.yml

@@ -70,6 +70,11 @@ jobs:
 
       - name: Build
         working-directory: website
+        env:
+          # Inject the cookieless GoatCounter beacon when provisioned. The site
+          # gates on process.env.GOATCOUNTER_CODE, which Actions does NOT
+          # auto-expose — the Actions variable must be mapped in explicitly.
+          GOATCOUNTER_CODE: ${{ vars.GOATCOUNTER_CODE }}
         run: npm run build
 
       - name: Upload Pages artifact

.github/workflows/stats.yml

@@ -0,0 +1,25 @@
+name: Adoption stats (maintainer-only)
+# Posts unified PyPI install + docs-traffic numbers to the workflow run summary,
+# which is visible ONLY to repo collaborators. Nothing is published publicly.
+on:
+  schedule:
+    - cron: '0 6 * * *'
+  workflow_dispatch: {}
+permissions:
+  contents: read
+jobs:
+  stats:
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: actions/setup-node@v4
+        with: { node-version: 20 }
+      - name: Fetch + summarize stats (private to collaborators)
+        env:
+          # public stars/forks work with the default token; unique cloners/viewers
+          # need a maintainer PAT with Administration: read (STATS_GITHUB_TOKEN).
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+          STATS_GITHUB_TOKEN: ${{ secrets.STATS_GITHUB_TOKEN }}
+          GOATCOUNTER_TOKEN: ${{ secrets.GOATCOUNTER_TOKEN }}
+          GOATCOUNTER_SITE: ${{ secrets.GOATCOUNTER_SITE }}
+        run: node website/scripts/fetch-stats.mjs >> "$GITHUB_STEP_SUMMARY"

.gitignore

@@ -69,3 +69,7 @@ tools/.unity-check-logs/
 # Ignore the .claude directory, since it might contain local/project-level setting such as deny and allowlist.
 /.claude
 .mcp.json
+
+# Superpowers skill working artifacts (specs, plans, SDD ledger)
+docs/superpowers/
+.superpowers/

MCPForUnity/Editor/Constants/EditorPrefKeys.cs

@@ -73,5 +73,14 @@ internal static class EditorPrefKeys
         internal const string LogRecordEnabled = "MCPForUnity.LogRecordEnabled";
 
         internal const string ExecuteCodeCompiler = "MCPForUnity.ExecuteCode.Compiler";
+
+        // AI Asset Generation — NON-SECRET config only. Provider API keys live in the OS
+        // secure store (MCPForUnity.Editor.Security.SecureKeyStore), never in EditorPrefs.
+        internal const string AssetGenSelectedModelProvider = "MCPForUnity.AssetGen.ModelProvider";
+        internal const string AssetGenSelectedImageProvider = "MCPForUnity.AssetGen.ImageProvider";
+        internal const string AssetGenDefaultFormat = "MCPForUnity.AssetGen.Format";
+        internal const string AssetGenOutputRoot = "MCPForUnity.AssetGen.OutputRoot";
+        internal const string AssetGenAutoNormalize = "MCPForUnity.AssetGen.AutoNormalize";
+        internal const string AssetGenProviderEnabledPrefix = "MCPForUnity.AssetGen.Enabled.";
     }
 }

MCPForUnity/Editor/Constants/ProductInfo.cs

@@ -0,0 +1,9 @@
+namespace MCPForUnity.Editor.Constants
+{
+    /// <summary>Canonical user-facing product identity strings.</summary>
+    public static class ProductInfo
+    {
+        public const string ProductName = "MCP for Unity";
+        public const string MenuRoot = "Window/MCP for Unity";
+    }
+}

MCPForUnity/Editor/Constants/ProductInfo.cs.meta

@@ -0,0 +1,90 @@
+using System;
+using System.IO;
+using UnityEngine;
+
+namespace MCPForUnity.Editor.Helpers
+{
+    /// <summary>
+    /// Project-path conversions shared by the asset-gen import/write code: project-relative
+    /// ("Assets/...") ↔ absolute on-disk paths, with forward-slash normalization for
+    /// cross-platform consistency.
+    /// </summary>
+    public static class AssetGenPaths
+    {
+        /// <summary>Resolve a project-relative ("Assets/...") path to an absolute, forward-slashed path.</summary>
+        public static string ToAbsolute(string projectRelative)
+        {
+            if (string.IsNullOrWhiteSpace(projectRelative)) return projectRelative;
+            string p = projectRelative.Replace('\\', '/');
+            string abs = Path.IsPathRooted(p) ? p : Path.Combine(ProjectRoot(), p);
+            return Path.GetFullPath(abs).Replace('\\', '/');
+        }
+
+        /// <summary>Convert an absolute (or already-relative) path to a project-relative ("Assets/...") path.</summary>
+        public static string ToProjectRelative(string path)
+        {
+            if (TryGetAssetsRelativePath(path, out string rel)) return rel;
+            return path?.Replace('\\', '/');
+        }
+
+        /// <summary>
+        /// Normalize an absolute or "Assets/..." path and verify it resolves inside the project's
+        /// Assets directory. Rejects traversal such as "Assets/../ProjectSettings".
+        /// </summary>
+        public static bool TryGetAssetsRelativePath(string path, out string projectRelative)
+        {
+            projectRelative = null;
+            if (string.IsNullOrWhiteSpace(path)) return false;
+
+            try
+            {
+                string p = path.Replace('\\', '/');
+                string abs;
+                if (p == "Assets" || p.StartsWith("Assets/", StringComparison.Ordinal))
+                {
+                    abs = Path.Combine(ProjectRoot(), p);
+                }
+                else if (Path.IsPathRooted(p))
+                {
+                    abs = p;
+                }
+                else
+                {
+                    return false;
+                }
+
+                string full = Path.GetFullPath(abs).Replace('\\', '/');
+                string dataPath = Path.GetFullPath(Application.dataPath).Replace('\\', '/').TrimEnd('/');
+                if (string.Equals(full, dataPath, StringComparison.Ordinal))
+                {
+                    projectRelative = "Assets";
+                    return true;
+                }
+
+                string prefix = dataPath + "/";
+                if (!full.StartsWith(prefix, StringComparison.Ordinal)) return false;
+
+                projectRelative = "Assets/" + full.Substring(prefix.Length);
+                return true;
+            }
+            catch
+            {
+                return false;
+            }
+        }
+
+        /// <summary>Normalize an Assets folder path, trimming trailing slashes.</summary>
+        public static bool TryGetAssetsFolder(string path, out string projectRelative)
+        {
+            if (!TryGetAssetsRelativePath(path, out projectRelative)) return false;
+            projectRelative = projectRelative.TrimEnd('/');
+            return true;
+        }
+
+        private static string ProjectRoot()
+        {
+            string dataPath = Path.GetFullPath(Application.dataPath).Replace('\\', '/');
+            return dataPath.Substring(0, dataPath.Length - "Assets".Length);
+        }
+    }
+}