@alpsckr/unitycli 0.4.0

package/extensions/probuilder/unitypkg/Editor/ProBuilder/mesh-info.cs

@@ -0,0 +1,117 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityCli.ProBuilder
+{
+    /// <summary>
+    /// probuilder.mesh-info — 获取 ProBuilder 网格的详细信息。
+    /// </summary>
+    public class MeshInfoTool : IUnityCliTool<MeshInfoTool.Request, MeshInfoTool.Result>
+    {
+        public sealed class Request
+        {
+            [UnityCliRequired] public string Target { get; set; }
+            public string Include { get; set; }                     // 可选,保留字段(summary/faces/edges/all)
+        }
+
+        public sealed class Result
+        {
+            public long VertexCount { get; set; }
+            public long FaceCount { get; set; }
+            public long EdgeCount { get; set; }
+            public BoundsInfo Bounds { get; set; }
+            public List<MaterialInfo> Materials { get; set; }
+        }
+
+        public sealed class BoundsInfo
+        {
+            public Vec3 Center { get; set; }
+            public Vec3 Size { get; set; }
+        }
+
+        public sealed class Vec3
+        {
+            public double X { get; set; }
+            public double Y { get; set; }
+            public double Z { get; set; }
+        }
+
+        public sealed class MaterialInfo
+        {
+            public string Name { get; set; }
+            public string Path { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "probuilder.mesh-info",
+            Summary = "Read detailed vertex, face, edge, bounds, and material info for a ProBuilder mesh.",
+            Description = "Get detailed information about a ProBuilder mesh including exact vertex, face, and edge counts from ProBuilderMesh, renderer bounds, and assigned materials.",
+            Group = "probuilder",
+            DestructiveHint = false,
+            Target = "editor",
+            PlayModeSupport = "editor-only",
+            DefaultTimeoutMs = 10000,
+            MaxTimeoutMs = 30000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "读取网格信息", Input = new Request { Target = "MyCube" } }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (!ProBuilderReflection.IsAvailable)
+                throw ProBuilderErrors.PackageNotAvailable();
+
+            var go = ProBuilderInput.ResolveTarget(request.Target);
+            if (go == null)
+                throw ProBuilderErrors.TargetNotFound(request.Target);
+
+            var mesh = ProBuilderReflection.GetProBuilderMesh(go);
+            if (mesh == null)
+                throw ProBuilderErrors.OperationFailed("mesh-info", "GameObject does not have a ProBuilderMesh component.");
+
+            var faceCount = ProBuilderReflection.GetFaceCount(mesh);
+            var vertexCount = ProBuilderReflection.GetVertexCount(mesh);
+            var edgeCount = ProBuilderReflection.GetEdgeCount(mesh);
+            if (faceCount < 0 || vertexCount < 0 || edgeCount < 0)
+                throw ProBuilderErrors.OperationFailed("mesh-info", "Failed to read exact ProBuilderMesh counts.");
+
+            var result = new Result
+            {
+                VertexCount = vertexCount,
+                FaceCount = faceCount,
+                EdgeCount = edgeCount
+            };
+
+            var renderer = go.GetComponent<MeshRenderer>();
+            if (renderer != null)
+            {
+                var bounds = renderer.bounds;
+                result.Bounds = new BoundsInfo
+                {
+                    Center = new Vec3 { X = bounds.center.x, Y = bounds.center.y, Z = bounds.center.z },
+                    Size = new Vec3 { X = bounds.size.x, Y = bounds.size.y, Z = bounds.size.z }
+                };
+
+                var materials = new List<MaterialInfo>();
+                foreach (var mat in renderer.sharedMaterials)
+                {
+                    if (mat == null) continue;
+                    materials.Add(new MaterialInfo
+                    {
+                        Name = mat.name,
+                        Path = AssetDatabase.GetAssetPath(mat)
+                    });
+                }
+                result.Materials = materials;
+            }
+
+            return new System.Threading.Tasks.ValueTask<Result>(result);
+        }
+    }
+}
+#endif

package/extensions/probuilder/unitypkg/Editor/ProBuilder/move-vertices.cs

@@ -0,0 +1,33 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+
+namespace UnityCli.ProBuilder
+{
+    /// <summary>probuilder.move-vertices — 按偏移量移动 ProBuilder 网格的选定顶点。</summary>
+    public class MoveVerticesTool : IUnityCliTool<MoveVerticesTool.Request, MoveVerticesTool.Result>
+    {
+        public sealed class Request { [UnityCliRequired] public string Target { get; set; } [UnityCliRequired] public List<long> VertexIndices { get; set; } public double X { get; set; } public double Y { get; set; } public double Z { get; set; } }
+        public sealed class Result { public long MovedCount { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "probuilder.move-vertices", Summary = "Move selected vertices of a ProBuilder mesh by an offset.", Description = "Move unique raw vertex indices by an X/Y/Z offset. Move validated raw vertex indices by a finite X/Y/Z offset.", Group = "probuilder", DestructiveHint = false, SideEffects = new[] { "scene-modify", "undo-stack" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 10000, MaxTimeoutMs = 30000, Examples = new[] { new ToolExample { Description = "沿 Y 轴移动顶点 0", Input = new Request { Target = "MyCube", VertexIndices = new List<long> { 0 }, Y = 0.5 } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (!ProBuilderReflection.IsAvailable) throw ProBuilderErrors.PackageNotAvailable();
+            var target = request.Target; var go = ProBuilderInput.ResolveTarget(target); if (go == null) throw ProBuilderErrors.TargetNotFound(target);
+            var mesh = ProBuilderReflection.GetProBuilderMesh(go); if (mesh == null) throw ProBuilderErrors.OperationFailed("move-vertices", "No ProBuilderMesh on target.");
+            var indexes = request.VertexIndices?.Select(value => ProBuilderOperationProof.CheckedInt(value, "vertexIndices")).ToArray();
+            var offset = ProBuilderOperationProof.CheckedVector3(request.X, request.Y, request.Z, "offset");
+            ProBuilderOperationProof.ValidateVertexIndices(mesh, indexes);
+            if (offset == Vector3.zero) return new System.Threading.Tasks.ValueTask<Result>(new Result { MovedCount = 0 });
+            var before = ProBuilderAtomicReadback.CapturePositions(mesh); if (before == null) throw ProBuilderErrors.OperationFailed("move-vertices", "Raw vertex positions are unreadable.");
+            ctx.CommitEffect();
+            try { ProBuilderAtomicReadback.RegisterMeshUndo(go, mesh, "ProBuilder Move Vertices"); var moved = ProBuilderReflection.MoveVerticesByOffset(mesh, indexes, offset); if (moved != indexes.Length) throw ProBuilderErrors.OutcomeUnknown("move-vertices", "invoke", "The frozen raw selection was not fully moved."); if (!ProBuilderReflection.RefreshMesh(mesh)) throw ProBuilderErrors.OutcomeUnknown("move-vertices", "readback", "ProBuilder refresh failed after the effect."); EditorSceneManager.MarkSceneDirty(go.scene); var fresh = ProBuilderReflection.GetProBuilderMesh(EditorUtility.InstanceIDToObject(go.GetInstanceID()) as GameObject); if (fresh == null) throw ProBuilderErrors.OutcomeUnknown("move-vertices", "readback", "Fresh target mesh is unreadable."); if (!ProBuilderAtomicReadback.VerticesMovedByOffset(fresh, before, indexes, offset)) throw ProBuilderErrors.OutcomeUnknown("move-vertices", "postcondition", "The requested vertices did not have the requested offset."); return new System.Threading.Tasks.ValueTask<Result>(new Result { MovedCount = moved }); }
+            catch (Exception exception) when (!(exception is UnityCliBridge.BridgeCommandException)) { throw ProBuilderErrors.OutcomeUnknown("move-vertices", "invoke", exception.Message); }
+        }
+    }
+}
+#endif

package/extensions/probuilder/unitypkg/Editor/ProBuilder/ping.cs

@@ -0,0 +1,51 @@
+#if UNITY_EDITOR
+using UnityEngine;
+
+namespace UnityCli.ProBuilder
+{
+    /// <summary>
+    /// probuilder.ping — 检查 ProBuilder 包可用性与桥接状态。
+    /// </summary>
+    public class PingTool : IUnityCliTool<PingTool.Request, PingTool.Result>
+    {
+        public sealed class Request
+        {
+            // 无输入字段
+        }
+
+        public sealed class Result
+        {
+            public bool Installed { get; set; }
+            public bool MeshTypeAvailable { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "probuilder.ping",
+            Summary = "Check ProBuilder package availability and bridge status.",
+            Description = "Check ProBuilder package availability and bridge status. Returns whether the package is installed and whether the ProBuilderMesh type is resolvable. No input required.",
+            Group = "probuilder",
+            DestructiveHint = false,
+            Target = "editor",
+            PlayModeSupport = "editor-only",
+            DefaultTimeoutMs = 5000,
+            MaxTimeoutMs = 10000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "探测 ProBuilder 可用性", Input = new Request() }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var available = ProBuilderReflection.IsAvailable;
+            var meshTypeAvailable = ProBuilderReflection.GetProBuilderMeshType() != null;
+            return new System.Threading.Tasks.ValueTask<Result>(new Result
+            {
+                Installed = available,
+                MeshTypeAvailable = meshTypeAvailable
+            });
+        }
+    }
+}
+#endif

package/extensions/probuilder/unitypkg/Editor/ProBuilder/repair-mesh.cs

@@ -0,0 +1,40 @@
+#if UNITY_EDITOR
+using System;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+namespace UnityCli.ProBuilder
+{
+    public class RepairMeshTool : IUnityCliTool<RepairMeshTool.Request, RepairMeshTool.Result>
+    {
+        public sealed class Request { [UnityCliRequired] public string Target { get; set; } }
+        public sealed class Result { public long RemovedDegenerateIndexCount { get; set; } public long RemovedUnusedVertexCount { get; set; } public long RemainingDegenerateFaceCount { get; set; } public long RemainingUnusedVertexCount { get; set; } }
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "probuilder.repair-mesh",
+            Summary = "Repair degenerate triangles and unused vertices.",
+            Description = "Remove readable degenerate triangles and unused vertices from a ProBuilder mesh.",
+            Group = "probuilder",
+            DestructiveHint = false,
+            SideEffects = new[] { "scene-modify", "undo-stack" },
+            Target = "editor",
+            PlayModeSupport = "editor-only",
+            DefaultTimeoutMs = 10000,
+            MaxTimeoutMs = 30000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "移除唯一未使用顶点", Input = new Request { Target = "TriangleWithUnusedRaw" } }
+            }
+        };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (!ProBuilderReflection.IsAvailable) throw ProBuilderErrors.PackageNotAvailable(); var go = ProBuilderInput.ResolveTarget(request.Target); if (go == null) throw ProBuilderErrors.TargetNotFound(request.Target); var mesh = ProBuilderReflection.GetProBuilderMesh(go); if (mesh == null) throw ProBuilderErrors.OperationFailed("repair-mesh", "No ProBuilderMesh on target.");
+            var beforeDegenerate = ProBuilderReflection.CountDegenerateFaces(mesh); var beforeUnused = ProBuilderReflection.CountUnusedVertices(mesh); if (beforeDegenerate < 0 || beforeUnused < 0) throw ProBuilderErrors.OperationFailed("repair-mesh", "Failed to read repairable mesh state."); if (beforeDegenerate == 0 && beforeUnused == 0) throw ProBuilderErrors.OperationFailed("repair-mesh", "Mesh has no readable degenerate triangles or unused vertices to repair."); var id = go.GetInstanceID(); ctx.CommitEffect(); int removedDegenerate; int removedUnused;
+            try { ProBuilderAtomicReadback.RegisterMeshUndo(go, mesh, "ProBuilder Repair Mesh"); removedDegenerate = ProBuilderReflection.RemoveDegenerateTriangles(mesh); removedUnused = ProBuilderReflection.RemoveUnusedVertices(mesh); if (removedDegenerate < 0 || removedUnused < 0) throw ProBuilderErrors.OutcomeUnknown("repair-mesh", "invoke", "Repair API failed."); }
+            catch (UnityCliBridge.BridgeCommandException) { throw; } catch (Exception ex) { throw ProBuilderErrors.OutcomeUnknown("repair-mesh", "invoke", ex.Message); }
+            try { if (!ProBuilderReflection.RefreshMeshPreservingVertexPayload(mesh)) throw ProBuilderErrors.OutcomeUnknown("repair-mesh", "readback", "ProBuilder refresh failed."); EditorSceneManager.MarkSceneDirty(go.scene); var fresh = ProBuilderReflection.GetProBuilderMesh(EditorUtility.InstanceIDToObject(id) as GameObject); var remainingDegenerate = ProBuilderReflection.CountDegenerateFaces(fresh); var remainingUnused = ProBuilderReflection.CountUnusedVertices(fresh); if (remainingDegenerate != 0 || remainingUnused != 0) throw ProBuilderErrors.OutcomeUnknown("repair-mesh", "postcondition", "Fresh repair counts did not show progress."); return new System.Threading.Tasks.ValueTask<Result>(new Result { RemovedDegenerateIndexCount = removedDegenerate, RemovedUnusedVertexCount = removedUnused, RemainingDegenerateFaceCount = remainingDegenerate, RemainingUnusedVertexCount = remainingUnused }); }
+            catch (UnityCliBridge.BridgeCommandException) { throw; } catch (Exception ex) { throw ProBuilderErrors.OutcomeUnknown("repair-mesh", "readback", ex.Message); }
+        }
+    }
+}
+#endif

package/extensions/probuilder/unitypkg/Editor/ProBuilder/select-faces.cs

@@ -0,0 +1,161 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityCli.ProBuilder
+{
+    /// <summary>
+    /// probuilder.select-faces — 按方向/增长/洪水/循环/环选 ProBuilder 网格的面。
+    /// </summary>
+    public class SelectFacesTool : IUnityCliTool<SelectFacesTool.Request, SelectFacesTool.Result>
+    {
+        public sealed class Request
+        {
+            [UnityCliRequired] public string Target { get; set; }
+            public string Direction { get; set; }                   // 可选:north/south/east/west/up/down
+            public List<long> SeedFaceIndices { get; set; }         // grow/flood/loop/ring 的种子面
+            public long? Grow { get; set; }                         // 可选:增长迭代次数
+            public bool Flood { get; set; }                         // 默认 false
+            public bool Loop { get; set; }                          // 默认 false
+            public bool Ring { get; set; }                          // 默认 false
+        }
+
+        public sealed class Result
+        {
+            public List<long> FaceIndices { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "probuilder.select-faces",
+            Summary = "Resolve ProBuilder face indices by direction or the 5.x ElementSelection grow, flood, loop, and ring APIs.",
+            Description = "Return matching face indices without changing Unity selection. Choose exactly one mode. Direction matches cardinal normals. Grow, loop, and ring require seedFaceIndices; flood uses seeds when provided and otherwise returns all faces.",
+            Group = "probuilder",
+            DestructiveHint = false,
+            Target = "editor",
+            PlayModeSupport = "editor-only",
+            DefaultTimeoutMs = 10000,
+            MaxTimeoutMs = 30000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "选择朝上的面", Input = new Request { Target = "MyCube", Direction = "up" } },
+                new ToolExample { Description = "选择所有面", Input = new Request { Target = "MyCube", Flood = true } }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (!ProBuilderReflection.IsAvailable)
+                throw ProBuilderErrors.PackageNotAvailable();
+
+            var go = ProBuilderInput.ResolveTarget(request.Target);
+            if (go == null) throw ProBuilderErrors.TargetNotFound(request.Target);
+
+            var mesh = ProBuilderReflection.GetProBuilderMesh(go);
+            if (mesh == null) throw ProBuilderErrors.OperationFailed("select-faces", "No ProBuilderMesh on target.");
+
+            var allFaces = ProBuilderReflection.GetAllFaces(mesh);
+            if (allFaces == null)
+                throw ProBuilderErrors.OperationFailed("select-faces", "Could not read faces from ProBuilderMesh.");
+
+            var direction = request.Direction;
+            var flood = request.Flood;
+            var grow = request.Grow;
+            var loop = request.Loop;
+            var ring = request.Ring;
+
+            var modeCount = (!string.IsNullOrEmpty(direction) ? 1 : 0) + (grow.HasValue ? 1 : 0) + (flood ? 1 : 0) + (loop ? 1 : 0) + (ring ? 1 : 0);
+            if (modeCount != 1)
+                throw ProBuilderErrors.SchemaInvalid("Choose exactly one of direction, grow, flood, loop, or ring.");
+
+            var selectedIndices = new List<int>();
+            if (!string.IsNullOrEmpty(direction))
+            {
+                var targetDir = ParseDirection(direction);
+                const float tolerance = 0.7f;
+                for (int i = 0; i < allFaces.Length; i++)
+                {
+                    var normal = ProBuilderReflection.ComputeFaceNormal(mesh, allFaces.GetValue(i));
+                    if (normal == Vector3.zero)
+                        throw ProBuilderErrors.OperationFailed("select-faces", "Could not read a non-zero normal for face index " + i + ".");
+                    if (Vector3.Dot(normal, targetDir) > tolerance)
+                        selectedIndices.Add(i);
+                }
+            }
+            else if (flood && (request.SeedFaceIndices == null || request.SeedFaceIndices.Count == 0))
+            {
+                for (int i = 0; i < allFaces.Length; i++)
+                    selectedIndices.Add(i);
+            }
+            else
+            {
+                if (request.SeedFaceIndices == null || request.SeedFaceIndices.Count == 0)
+                    throw ProBuilderErrors.SchemaInvalid("seedFaceIndices is required for grow, seeded flood, loop, and ring.");
+                if (grow.HasValue && grow.Value < 1)
+                    throw ProBuilderErrors.SchemaInvalid("grow must be at least 1.");
+
+                var seedIndices = request.SeedFaceIndices.Select(value => ProBuilderOperationProof.CheckedInt(value, "seedFaceIndices")).ToArray();
+                var seeds = ProBuilderReflection.GetFacesByIndices(mesh, seedIndices);
+                if (seeds == null || seeds.Length != seedIndices.Length)
+                    throw ProBuilderErrors.SchemaInvalid("seedFaceIndices contains an invalid face index.");
+
+                var operation = grow.HasValue ? "grow" : flood ? "flood" : loop ? "loop" : "ring";
+                var selectedFaces = ProBuilderReflection.SelectFaces(mesh, seeds, operation, ProBuilderOperationProof.CheckedInt(grow ?? 1, "grow"));
+                if (selectedFaces == null)
+                    throw ProBuilderErrors.OperationFailed("select-faces", "ProBuilder 5.x ElementSelection failed for operation: " + operation);
+                selectedIndices.AddRange(ResolveFaceIndices(allFaces, selectedFaces));
+            }
+
+            selectedIndices.Sort();
+
+            // 转 long 列表
+            var resultIndices = new List<long>();
+            foreach (var idx in selectedIndices) resultIndices.Add(idx);
+
+            return new System.Threading.Tasks.ValueTask<Result>(new Result { FaceIndices = resultIndices });
+        }
+
+        /// <summary>将公开方向名称映射为 Unity 局部空间方向。</summary>
+        private static Vector3 ParseDirection(string direction)
+        {
+            switch (direction.ToLowerInvariant())
+            {
+                case "north":
+                case "forward":
+                case "front": return Vector3.forward;
+                case "south":
+                case "back":
+                case "backward": return Vector3.back;
+                case "east":
+                case "right": return Vector3.right;
+                case "west":
+                case "left": return Vector3.left;
+                case "up":
+                case "top": return Vector3.up;
+                case "down":
+                case "bottom": return Vector3.down;
+                default: throw ProBuilderErrors.SchemaInvalid($"Unknown direction '{direction}'. Valid: north/south/east/west/up/down.");
+            }
+        }
+
+        /// <summary>把 ElementSelection 返回的 Face 引用映射回稳定面索引。</summary>
+        private static List<int> ResolveFaceIndices(Array allFaces, Array selectedFaces)
+        {
+            var indices = new List<int>();
+            foreach (var selected in selectedFaces)
+            {
+                for (var index = 0; index < allFaces.Length; index++)
+                {
+                    if (!ReferenceEquals(allFaces.GetValue(index), selected)) continue;
+                    indices.Add(index);
+                    break;
+                }
+            }
+            return indices;
+        }
+    }
+}
+#endif

package/extensions/probuilder/unitypkg/Editor/ProBuilder/set-face-color.cs

@@ -0,0 +1,24 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+namespace UnityCli.ProBuilder
+{
+    public class SetFaceColorTool : IUnityCliTool<SetFaceColorTool.Request, SetFaceColorTool.Result>
+    {
+        public sealed class Request { [UnityCliRequired] public string Target { get; set; } public List<long> FaceIndices { get; set; } public double? R { get; set; } public double? G { get; set; } public double? B { get; set; } public double? A { get; set; } }
+        public sealed class Result { public long ColoredFaceCount { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "probuilder.set-face-color", Summary = "Set vertex color of selected faces on a ProBuilder mesh.", Description = "Set selected face vertex colors.", Group = "probuilder", DestructiveHint = false, SideEffects = new[] { "scene-modify", "undo-stack" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 10000, MaxTimeoutMs = 30000, Examples = new[] { new ToolExample { Description = "将面 0 设为红色", Input = new Request { Target = "MyCube", FaceIndices = new List<long> { 0 }, R = 1, G = 0, B = 0, A = 1 } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (!ProBuilderReflection.IsAvailable) throw ProBuilderErrors.PackageNotAvailable(); var target = request.Target; var go = ProBuilderInput.ResolveTarget(target); if (go == null) throw ProBuilderErrors.TargetNotFound(target); var mesh = ProBuilderReflection.GetProBuilderMesh(go); if (mesh == null) throw ProBuilderErrors.OperationFailed("set-face-color", "No ProBuilderMesh on target.");
+            var color = new Color(ProBuilderOperationProof.CheckedFloat(request.R ?? 1d, "r"), ProBuilderOperationProof.CheckedFloat(request.G ?? 1d, "g"), ProBuilderOperationProof.CheckedFloat(request.B ?? 1d, "b"), ProBuilderOperationProof.CheckedFloat(request.A ?? 1d, "a")); if (color.r < 0 || color.r > 1 || color.g < 0 || color.g > 1 || color.b < 0 || color.b > 1 || color.a < 0 || color.a > 1) throw ProBuilderErrors.SchemaInvalid("Color channels must be between 0 and 1.");
+            var indexes = request.FaceIndices?.Select(value => ProBuilderOperationProof.CheckedInt(value, "faceIndices")).ToArray(); if (indexes == null || indexes.Length == 0) indexes = Enumerable.Range(0, ProBuilderReflection.GetFaceCount(mesh)).ToArray(); var faces = ProBuilderReflection.GetFacesByIndices(mesh, indexes); if (faces == null || indexes.Distinct().Count() != indexes.Length) throw ProBuilderErrors.SchemaInvalid("faceIndices must identify unique valid faces."); if (ProBuilderAtomicReadback.RequestedFacesHaveColor(mesh, indexes, color)) return new System.Threading.Tasks.ValueTask<Result>(new Result { ColoredFaceCount = 0 });
+            ctx.CommitEffect(); try { ProBuilderAtomicReadback.RegisterMeshUndo(go, mesh, "ProBuilder Set Face Color"); if (!ProBuilderReflection.SetFaceColor(mesh, faces, color)) throw ProBuilderErrors.OutcomeUnknown("set-face-color", "invoke", "ProBuilderMesh.SetFaceColor failed."); if (!ProBuilderReflection.RefreshMesh(mesh)) throw ProBuilderErrors.OutcomeUnknown("set-face-color", "readback", "ProBuilder refresh failed after the effect."); EditorSceneManager.MarkSceneDirty(go.scene); var fresh = ProBuilderReflection.GetProBuilderMesh(EditorUtility.InstanceIDToObject(go.GetInstanceID()) as GameObject); if (fresh == null) throw ProBuilderErrors.OutcomeUnknown("set-face-color", "readback", "Fresh target mesh is unreadable."); if (!ProBuilderAtomicReadback.RequestedFacesHaveColor(fresh, indexes, color)) throw ProBuilderErrors.OutcomeUnknown("set-face-color", "postcondition", "The requested faces do not have the requested color."); return new System.Threading.Tasks.ValueTask<Result>(new Result { ColoredFaceCount = faces.Length }); } catch (Exception exception) when (!(exception is UnityCliBridge.BridgeCommandException)) { throw ProBuilderErrors.OutcomeUnknown("set-face-color", "invoke", exception.Message); }
+        }
+    }
+}
+#endif

package/extensions/probuilder/unitypkg/Editor/ProBuilder/set-face-material.cs

@@ -0,0 +1,23 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+namespace UnityCli.ProBuilder
+{
+    public class SetFaceMaterialTool : IUnityCliTool<SetFaceMaterialTool.Request, SetFaceMaterialTool.Result>
+    {
+        public sealed class Request { [UnityCliRequired] public string Target { get; set; } public List<long> FaceIndices { get; set; } [UnityCliRequired] public string MaterialPath { get; set; } }
+        public sealed class Result { public long AssignedFaceCount { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "probuilder.set-face-material", Summary = "Assign a material asset to selected faces of a ProBuilder mesh.", Description = "Assign a material asset to selected faces.", Group = "probuilder", DestructiveHint = false, SideEffects = new[] { "scene-modify", "undo-stack" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 10000, MaxTimeoutMs = 30000, Examples = new[] { new ToolExample { Description = "为面 0 分配材质", Input = new Request { Target = "MyTwoMaterialMesh", FaceIndices = new List<long> { 0 }, MaterialPath = "Assets/Materials/Existing.mat" } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (!ProBuilderReflection.IsAvailable) throw ProBuilderErrors.PackageNotAvailable(); var target = request.Target; var go = ProBuilderInput.ResolveTarget(target); if (go == null) throw ProBuilderErrors.TargetNotFound(target); var mesh = ProBuilderReflection.GetProBuilderMesh(go); if (mesh == null) throw ProBuilderErrors.OperationFailed("set-face-material", "No ProBuilderMesh on target."); var material = string.IsNullOrEmpty(request.MaterialPath) ? null : AssetDatabase.LoadAssetAtPath<Material>(request.MaterialPath); if (material == null) throw ProBuilderErrors.OperationFailed("set-face-material", "Material not found at path: " + request.MaterialPath);
+            var indexes = request.FaceIndices?.Select(value => ProBuilderOperationProof.CheckedInt(value, "faceIndices")).ToArray(); if (indexes == null || indexes.Length == 0) indexes = Enumerable.Range(0, ProBuilderReflection.GetFaceCount(mesh)).ToArray(); var faces = ProBuilderReflection.GetFacesByIndices(mesh, indexes); if (faces == null || indexes.Distinct().Count() != indexes.Length || go.GetComponent<Renderer>() == null) throw ProBuilderErrors.SchemaInvalid("faceIndices must identify unique valid faces and the target must have a renderer."); if (ProBuilderAtomicReadback.RequestedFacesUseMaterial(mesh, indexes, material)) return new System.Threading.Tasks.ValueTask<Result>(new Result { AssignedFaceCount = 0 });
+            ctx.CommitEffect(); try { ProBuilderAtomicReadback.RegisterMeshUndo(go, mesh, "ProBuilder Set Face Material", false, go.GetComponent<Renderer>()); if (!ProBuilderReflection.SetFaceMaterial(mesh, faces, material)) throw ProBuilderErrors.OutcomeUnknown("set-face-material", "invoke", "ProBuilderMesh.SetMaterial failed."); if (!ProBuilderReflection.RefreshMesh(mesh)) throw ProBuilderErrors.OutcomeUnknown("set-face-material", "readback", "ProBuilder refresh failed after the effect."); EditorSceneManager.MarkSceneDirty(go.scene); var fresh = ProBuilderReflection.GetProBuilderMesh(EditorUtility.InstanceIDToObject(go.GetInstanceID()) as GameObject); if (fresh == null) throw ProBuilderErrors.OutcomeUnknown("set-face-material", "readback", "Fresh target mesh is unreadable."); if (!ProBuilderAtomicReadback.RequestedFacesUseMaterial(fresh, indexes, material)) throw ProBuilderErrors.OutcomeUnknown("set-face-material", "postcondition", "The requested faces do not use the requested material."); return new System.Threading.Tasks.ValueTask<Result>(new Result { AssignedFaceCount = faces.Length }); } catch (Exception exception) when (!(exception is UnityCliBridge.BridgeCommandException)) { throw ProBuilderErrors.OutcomeUnknown("set-face-material", "invoke", exception.Message); }
+        }
+    }
+}
+#endif

package/extensions/probuilder/unitypkg/Editor/ProBuilder/set-face-uvs.cs

@@ -0,0 +1,28 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq;
+using System.Reflection;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.ProBuilder;
+namespace UnityCli.ProBuilder
+{
+    public class SetFaceUvsTool : IUnityCliTool<SetFaceUvsTool.Request, SetFaceUvsTool.Result>
+    {
+        public sealed class Request { [UnityCliRequired] public string Target { get; set; } public List<long> FaceIndices { get; set; } public double? Scale { get; set; } public double? OffsetU { get; set; } public double? OffsetV { get; set; } public double? Rotation { get; set; } public bool FlipU { get; set; } public bool FlipV { get; set; } }
+        public sealed class Result { public long UpdatedFaceCount { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "probuilder.set-face-uvs", Summary = "Set UV parameters for selected faces on a ProBuilder mesh.", Description = "Set AutoUnwrapSettings fields on selected faces.", Group = "probuilder", DestructiveHint = false, SideEffects = new[] { "scene-modify", "undo-stack" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 10000, MaxTimeoutMs = 30000, Examples = new[] { new ToolExample { Description = "将面 0 UV 缩放设为 2", Input = new Request { Target = "MyTriangle", FaceIndices = new List<long> { 0 }, Scale = 2 } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (!ProBuilderReflection.IsAvailable) throw ProBuilderErrors.PackageNotAvailable(); var target = request.Target; var flipU = request.FlipU; var flipV = request.FlipV; var go = ProBuilderInput.ResolveTarget(target); if (go == null) throw ProBuilderErrors.TargetNotFound(target); var mesh = ProBuilderReflection.GetProBuilderMesh(go); if (mesh == null) throw ProBuilderErrors.OperationFailed("set-face-uvs", "No ProBuilderMesh on target.");
+            var indexes = request.FaceIndices?.Select(value => ProBuilderOperationProof.CheckedInt(value, "faceIndices")).ToArray(); if (indexes == null || indexes.Length == 0) indexes = Enumerable.Range(0, ProBuilderReflection.GetFaceCount(mesh)).ToArray(); var faces = ProBuilderReflection.GetFacesByIndices(mesh, indexes); var scale = request.Scale.HasValue ? (float?)ProBuilderOperationProof.CheckedFloat(request.Scale.Value, "scale") : null; var u = request.OffsetU.HasValue ? (float?)ProBuilderOperationProof.CheckedFloat(request.OffsetU.Value, "offsetU") : null; var v = request.OffsetV.HasValue ? (float?)ProBuilderOperationProof.CheckedFloat(request.OffsetV.Value, "offsetV") : null; var rotation = request.Rotation.HasValue ? (float?)ProBuilderOperationProof.CheckedFloat(request.Rotation.Value, "rotation") : null;
+            if (faces == null || indexes.Distinct().Count() != indexes.Length) throw ProBuilderErrors.SchemaInvalid("faceIndices must identify unique valid faces."); if (ProBuilderAtomicReadback.RequestedFacesHaveUv(mesh, indexes, scale, u, v, rotation, flipU, flipV)) return new System.Threading.Tasks.ValueTask<Result>(new Result { UpdatedFaceCount = 0 });
+            var faceType = ProBuilderReflection.GetFaceType(); var uv = faceType?.GetProperty("uv", BindingFlags.Instance | BindingFlags.Public); var refreshType = faceType == null ? null : typeof(IEnumerable<>).MakeGenericType(faceType); var refresh = refreshType == null ? null : ProBuilderReflection.GetProBuilderMeshType()?.GetMethod("RefreshUV", BindingFlags.Instance | BindingFlags.Public, null, new[] { refreshType }, null); if (uv == null || !uv.CanRead || !uv.CanWrite || refresh == null) throw ProBuilderErrors.OperationFailed("set-face-uvs", "Required ProBuilder 5.2.4 UV members are unavailable.");
+            ctx.CommitEffect(); try { ProBuilderAtomicReadback.RegisterMeshUndo(go, mesh, "ProBuilder Set Face UVs"); foreach (var face in faces) { var value = (AutoUnwrapSettings)uv.GetValue(face); if (scale.HasValue) value.scale = new Vector2(scale.Value, scale.Value); if (u.HasValue || v.HasValue) value.offset = new Vector2(u ?? 0f, v ?? 0f); if (rotation.HasValue) value.rotation = rotation.Value; value.flipU = flipU; value.flipV = flipV; uv.SetValue(face, value); } refresh.Invoke(mesh, new object[] { faces }); if (!ProBuilderReflection.RefreshMesh(mesh)) throw ProBuilderErrors.OutcomeUnknown("set-face-uvs", "readback", "ProBuilder refresh failed after the effect."); EditorSceneManager.MarkSceneDirty(go.scene); var fresh = ProBuilderReflection.GetProBuilderMesh(EditorUtility.InstanceIDToObject(go.GetInstanceID()) as GameObject); if (fresh == null) throw ProBuilderErrors.OutcomeUnknown("set-face-uvs", "readback", "Fresh target mesh is unreadable."); if (!ProBuilderAtomicReadback.RequestedFacesHaveUv(fresh, indexes, scale, u, v, rotation, flipU, flipV)) throw ProBuilderErrors.OutcomeUnknown("set-face-uvs", "postcondition", "The requested faces do not have the requested UV settings."); return new System.Threading.Tasks.ValueTask<Result>(new Result { UpdatedFaceCount = faces.Length }); } catch (Exception exception) when (!(exception is UnityCliBridge.BridgeCommandException)) { throw ProBuilderErrors.OutcomeUnknown("set-face-uvs", "invoke", exception.Message); }
+        }
+    }
+}
+#endif

package/extensions/probuilder/unitypkg/Editor/ProBuilder/set-pivot.cs

@@ -0,0 +1,42 @@
+#if UNITY_EDITOR
+using System;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.ProBuilder;
+using UnityEngine.ProBuilder.MeshOperations;
+namespace UnityCli.ProBuilder
+{
+    /// <summary>probuilder.set-pivot — 将 ProBuilder 网格轴心设到指定位置。</summary>
+    public class SetPivotTool : IUnityCliTool<SetPivotTool.Request, SetPivotTool.Result>
+    {
+        public sealed class Request { [UnityCliRequired] public string Target { get; set; } public double? X { get; set; } public double? Y { get; set; } public double? Z { get; set; } }
+        public sealed class Result { public Vec3 NewPivotPosition { get; set; } }
+        public sealed class Vec3 { public double X { get; set; } public double Y { get; set; } public double Z { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "probuilder.set-pivot", Summary = "Set the pivot point of a ProBuilder mesh to a specific position.", Description = "Set a root object's world pivot point.", Group = "probuilder", DestructiveHint = false, SideEffects = new[] { "scene-modify", "undo-stack" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 10000, MaxTimeoutMs = 30000, Examples = new[] { new ToolExample { Description = "将轴心设到原点", Input = new Request { Target = "MyCube", X = 0, Y = 0, Z = 0 } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (!ProBuilderReflection.IsAvailable) throw ProBuilderErrors.PackageNotAvailable(); var target = request.Target; var go = ProBuilderInput.ResolveTarget(target); if (go == null) throw ProBuilderErrors.TargetNotFound(target); var mesh = ProBuilderReflection.GetProBuilderMesh(go) as ProBuilderMesh; if (mesh == null) throw ProBuilderErrors.OperationFailed("set-pivot", "No ProBuilderMesh on target.");
+            var position = go.transform.position; var pivot = new Vector3(request.X.HasValue ? ProBuilderOperationProof.CheckedFloat(request.X.Value, "x") : position.x, request.Y.HasValue ? ProBuilderOperationProof.CheckedFloat(request.Y.Value, "y") : position.y, request.Z.HasValue ? ProBuilderOperationProof.CheckedFloat(request.Z.Value, "z") : position.z);
+            if (go.transform.position == pivot) return new System.Threading.Tasks.ValueTask<Result>(new Result { NewPivotPosition = new Vec3 { X = pivot.x, Y = pivot.y, Z = pivot.z } }); var worldPositions = ProBuilderAtomicReadback.CaptureWorldPositions(go, mesh); if (worldPositions == null) throw ProBuilderErrors.OperationFailed("set-pivot", "Raw vertex positions are unreadable.");
+            var instanceId = go.GetInstanceID();
+            ctx.CommitEffect();
+            try
+            {
+                ProBuilderAtomicReadback.RegisterMeshUndo(go, mesh, "ProBuilder Set Pivot", true);
+                mesh.SetPivot(pivot);
+                EditorSceneManager.MarkSceneDirty(go.scene);
+                var freshGo = EditorUtility.InstanceIDToObject(instanceId) as GameObject;
+                var fresh = ProBuilderReflection.GetProBuilderMesh(freshGo);
+                if (fresh == null) throw ProBuilderErrors.OutcomeUnknown("set-pivot", "readback", "Fresh target mesh is unreadable.");
+                if (!ProBuilderAtomicReadback.PivotPreservesWorldGeometry(freshGo, fresh, pivot, worldPositions, false)) throw ProBuilderErrors.OutcomeUnknown("set-pivot", "postcondition", "Pivot or world geometry did not match the request.");
+                return new System.Threading.Tasks.ValueTask<Result>(new Result { NewPivotPosition = new Vec3 { X = pivot.x, Y = pivot.y, Z = pivot.z } });
+            }
+            catch (Exception exception) when (!(exception is UnityCliBridge.BridgeCommandException))
+            {
+                throw ProBuilderErrors.OutcomeUnknown("set-pivot", "invoke", exception.Message);
+            }
+        }
+    }
+}
+#endif

package/extensions/probuilder/unitypkg/Editor/ProBuilder/set-smoothing.cs

@@ -0,0 +1,23 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+namespace UnityCli.ProBuilder
+{
+    public class SetSmoothingTool : IUnityCliTool<SetSmoothingTool.Request, SetSmoothingTool.Result>
+    {
+        public sealed class Request { [UnityCliRequired] public string Target { get; set; } public List<long> FaceIndices { get; set; } [UnityCliRequired] public ushort SmoothingGroup { get; set; } }
+        public sealed class Result { public long ModifiedFaceCount { get; set; } }
+        public ToolDescriptor Describe() => new() { Name = "probuilder.set-smoothing", Summary = "Set the smoothing group for selected faces of a ProBuilder mesh.", Description = "Set selected face smoothing groups in the bounded 0..65535 domain.", Group = "probuilder", DestructiveHint = false, SideEffects = new[] { "scene-modify", "undo-stack" }, Target = "editor", PlayModeSupport = "editor-only", DefaultTimeoutMs = 10000, MaxTimeoutMs = 30000, Examples = new[] { new ToolExample { Description = "将面 0 设为平滑组 1", Input = new Request { Target = "MyCube", FaceIndices = new List<long> { 0 }, SmoothingGroup = 1 } } } };
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (!ProBuilderReflection.IsAvailable) throw ProBuilderErrors.PackageNotAvailable(); var target = request.Target; var go = ProBuilderInput.ResolveTarget(target); if (go == null) throw ProBuilderErrors.TargetNotFound(target); var mesh = ProBuilderReflection.GetProBuilderMesh(go); if (mesh == null) throw ProBuilderErrors.OperationFailed("set-smoothing", "No ProBuilderMesh on target."); var group = (int)request.SmoothingGroup;
+            var indexes = request.FaceIndices?.Select(value => ProBuilderOperationProof.CheckedInt(value, "faceIndices")).ToArray(); if (indexes == null || indexes.Length == 0) indexes = Enumerable.Range(0, ProBuilderReflection.GetFaceCount(mesh)).ToArray(); if (ProBuilderReflection.GetFacesByIndices(mesh, indexes) == null || indexes.Distinct().Count() != indexes.Length) throw ProBuilderErrors.SchemaInvalid("faceIndices must identify unique valid faces."); if (ProBuilderAtomicReadback.RequestedFacesHaveSmoothingGroup(mesh, indexes, group)) return new System.Threading.Tasks.ValueTask<Result>(new Result { ModifiedFaceCount = 0 });
+            ctx.CommitEffect(); try { ProBuilderAtomicReadback.RegisterMeshUndo(go, mesh, "ProBuilder Set Smoothing"); if (!ProBuilderReflection.ApplySmoothingGroup(mesh, indexes, group)) throw ProBuilderErrors.OutcomeUnknown("set-smoothing", "invoke", "Failed to set Face.smoothingGroup."); if (!ProBuilderReflection.RefreshMesh(mesh)) throw ProBuilderErrors.OutcomeUnknown("set-smoothing", "readback", "ProBuilder refresh failed after the effect."); EditorSceneManager.MarkSceneDirty(go.scene); var fresh = ProBuilderReflection.GetProBuilderMesh(EditorUtility.InstanceIDToObject(go.GetInstanceID()) as GameObject); if (fresh == null) throw ProBuilderErrors.OutcomeUnknown("set-smoothing", "readback", "Fresh target mesh is unreadable."); if (!ProBuilderAtomicReadback.RequestedFacesHaveSmoothingGroup(fresh, indexes, group)) throw ProBuilderErrors.OutcomeUnknown("set-smoothing", "postcondition", "The requested faces do not have the requested smoothing group."); return new System.Threading.Tasks.ValueTask<Result>(new Result { ModifiedFaceCount = indexes.Length }); } catch (Exception exception) when (!(exception is UnityCliBridge.BridgeCommandException)) { throw ProBuilderErrors.OutcomeUnknown("set-smoothing", "invoke", exception.Message); }
+        }
+    }
+}
+#endif