@alpsckr/unitycli 0.4.0

package/extensions/probuilder/unitypkg/Editor/ProBuilder/create-shape.cs

@@ -0,0 +1,168 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+
+namespace UnityCli.ProBuilder
+{
+    /// <summary>
+    /// probuilder.create-shape - 在场景中创建 ProBuilder 基本形状
+    /// </summary>
+    public class CreateShapeTool : IUnityCliTool<CreateShapeTool.Request, CreateShapeTool.Result>
+    {
+        public sealed class Request
+        {
+            [UnityCliRequired] public string ShapeType { get; set; }
+            public string Name { get; set; }                         // 可选，默认 ProBuilder_<shapeType>
+            public double X { get; set; }                            // 默认 0
+            public double Y { get; set; }                            // 默认 0
+            public double Z { get; set; }                            // ?? 0
+            public double? Width { get; set; }                       // 可选
+            public double? Height { get; set; }                       // 可选
+            public double? Depth { get; set; }                       // 可选
+        }
+
+        public sealed class Result
+        {
+            public ObjectRef Object { get; set; }
+        }
+
+        public sealed class ObjectRef
+        {
+            public long Id { get; set; }
+            public string Name { get; set; }
+            public string Path { get; set; }
+            public string Shape { get; set; }
+            public bool HasProBuilderMesh { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "probuilder.create-shape",
+            Summary = "Create a ProBuilder primitive shape in the active scene.",
+            Description = "Create a default primitive from the ProBuilder 5.2.4 topology record. Supports Cube, Stair, CurvedStair, Prism, Cylinder, Plane, Door, Pipe, Cone, Sprite, Arch, Sphere, and Torus. Plane and Sprite have a zero Y normal axis, so height is not accepted. Optionally set position and dimensions whose topology-record-derived scale remains finite. Other ProBuilder package versions are rejected before scene mutation.",
+            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 { ShapeType = "Cube" } },
+                new ToolExample { Description = "创建指定尺寸的圆柱", Input = new Request { ShapeType = "Cylinder", Width = 2, Height = 4, Depth = 2 } }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            if (!ProBuilderReflection.IsAvailable)
+                throw ProBuilderErrors.PackageNotAvailable();
+
+            var shapeType = request.ShapeType;
+            var requestedName = request.Name;
+            if (!IsSupportedShape(shapeType))
+                throw ProBuilderErrors.SchemaInvalid("Unsupported shapeType for probuilder.create-shape: " + shapeType + ". Supported values: " + SupportedShapeValues + ".");
+
+            var name = requestedName ?? ("ProBuilder_" + shapeType);
+            if (string.IsNullOrWhiteSpace(name)) throw ProBuilderErrors.SchemaInvalid("name must be non-empty.");
+            var activeScene = UnityEngine.SceneManagement.SceneManager.GetActiveScene();
+            if (!activeScene.IsValid() || !activeScene.isLoaded) throw ProBuilderErrors.SchemaInvalid("Active scene must be valid and loaded.");
+            var position = ProBuilderOperationProof.CheckedVector3(request.X, request.Y, request.Z, "position");
+            var width = request.Width.HasValue ? ProBuilderOperationProof.CheckedPositiveFloat(request.Width.Value, "width") : (float?)null;
+            var height = request.Height.HasValue ? ProBuilderOperationProof.CheckedPositiveFloat(request.Height.Value, "height") : (float?)null;
+            var depth = request.Depth.HasValue ? ProBuilderOperationProof.CheckedPositiveFloat(request.Depth.Value, "depth") : (float?)null;
+            // Plane does not support height; ShapeGenerator.CreateShape creates Plane and Sprite through GeneratePlane(... Axis.Up).
+            if (HasZeroYAxis(shapeType) && height.HasValue) throw ProBuilderErrors.SchemaInvalid(shapeType + " does not support an explicit height along its zero normal axis.");
+
+            // 所有成功条件必须在 effect 前冻结，禁止由创建结果反推请求语义。
+            var plan = ProBuilderVertexObjectCompletionProof.CaptureCreateShapePlan(shapeType, name, position, width, height, depth, activeScene);
+            if (plan == null)
+                throw ProBuilderErrors.SchemaInvalid("The ProBuilder 5.2.4 topology record or finite center-pivot bounds are unavailable; create-shape is fail-closed until the supported package is installed.");
+            ctx.CommitEffect();
+            try
+            {
+                var go = ProBuilderReflection.CreateShape(shapeType, position, Quaternion.identity);
+                if (go == null)
+                    throw ProBuilderErrors.OutcomeUnknown("create-shape", "invoke", "ProBuilder 5.2.4 ShapeGenerator.CreateShape failed for shape: " + shapeType);
+                go.name = name;
+                go.transform.localScale = plan.LocalScale;
+                Undo.RegisterCreatedObjectUndo(go, "ProBuilder Create Shape");
+                EditorSceneManager.MarkSceneDirty(go.scene);
+
+                var createdIdentity = ProBuilderOperationProof.CaptureIdentity(go);
+                var freshGo = ProBuilderOperationProof.ResolveFreshObject(go.GetInstanceID().ToString(), createdIdentity);
+                if (freshGo == null)
+                    throw ProBuilderErrors.OutcomeUnknown("create-shape", "readback", "Created object identity could not be resolved.");
+                var createdMesh = ProBuilderReflection.GetProBuilderMesh(freshGo);
+                var hasPbMesh = ProBuilderReflection.HasProBuilderMesh(freshGo);
+                if (createdMesh == null)
+                    throw ProBuilderErrors.OutcomeUnknown("create-shape", "readback", "Created ProBuilderMesh could not be read.");
+                var mismatch = hasPbMesh ? ProBuilderVertexObjectCompletionProof.CreatedShapeMismatch(plan, freshGo, createdMesh, createdIdentity) : "probuilder-component";
+                if (mismatch != null)
+                    throw ProBuilderErrors.OutcomeUnknown("create-shape", "postcondition", "Fresh readback did not prove the frozen ProBuilder 5.2.4 condition: " + mismatch + ".");
+                return new System.Threading.Tasks.ValueTask<Result>(new Result
+                {
+                    Object = new ObjectRef
+                    {
+                        Id = freshGo.GetInstanceID(),
+                        Name = freshGo.name,
+                        Path = HierarchyPath(freshGo),
+                        Shape = shapeType,
+                        HasProBuilderMesh = hasPbMesh
+                    }
+                });
+            }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch (System.Exception exception)
+            {
+                throw ProBuilderErrors.OutcomeUnknown("create-shape", "postcondition", exception.Message);
+            }
+        }
+
+        private const string SupportedShapeValues = "Cube, Stair, CurvedStair, Prism, Cylinder, Plane, Door, Pipe, Cone, Sprite, Arch, Sphere, Torus";
+
+        /// <summary>内部证明辅助逻辑。</summary>
+        private static bool IsSupportedShape(string shapeType)
+        {
+            switch (shapeType ?? string.Empty)
+            {
+                case "Cube":
+                case "Cylinder":
+                case "Sphere":
+                case "Plane":
+                case "Cone":
+                case "Sprite":
+                case "Torus":
+                case "Pipe":
+                case "Arch":
+                case "Stair":
+                case "CurvedStair":
+                case "Door":
+                case "Prism":
+                    return true;
+                default:
+                    return false;
+            }
+        }
+
+        private static bool HasZeroYAxis(string shapeType) => shapeType == "Plane" || shapeType == "Sprite";
+
+        private static string HierarchyPath(GameObject go)
+        {
+            var names = new Stack<string>();
+            var current = go.transform;
+            while (current != null)
+            {
+                names.Push(current.name);
+                current = current.parent;
+            }
+            return string.Join("/", names.ToArray());
+        }
+    }
+}
+#endif

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

@@ -0,0 +1,42 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+namespace UnityCli.ProBuilder
+{
+    public class DeleteFacesTool : IUnityCliTool<DeleteFacesTool.Request, DeleteFacesTool.Result>
+    {
+        public sealed class Request { [UnityCliRequired] public string Target { get; set; } [UnityCliRequired] public List<long> FaceIndices { get; set; } }
+        public sealed class Result { public long DeletedCount { get; set; } public long RemainingFaceCount { get; set; } }
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "probuilder.delete-faces",
+            Summary = "Delete selected faces from a ProBuilder mesh.",
+            Description = "Delete at least one unique valid face index 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 { FaceIndices = new List<long> { 0 }, Target = "SingleTriangle" } }
+            }
+        };
+        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("delete-faces", "No ProBuilderMesh on target.");
+            var indices = request.FaceIndices?.Select(value => ProBuilderOperationProof.CheckedInt(value, "faceIndices")).ToArray(); var before = ProBuilderReflection.GetFaceCount(mesh); if (indices == null || indices.Length == 0 || indices.Distinct().Count() != indices.Length || before < 0 || ProBuilderReflection.GetFacesByIndices(mesh, indices) == null) throw ProBuilderErrors.SchemaInvalid("faceIndices must contain unique valid faces."); var id = go.GetInstanceID(); ctx.CommitEffect();
+            try { ProBuilderAtomicReadback.RegisterMeshUndo(go, mesh, "ProBuilder Delete Faces"); if (!ProBuilderReflection.DeleteFaces(mesh, indices)) throw ProBuilderErrors.OutcomeUnknown("delete-faces", "invoke", "DeleteFaces failed."); }
+            catch (UnityCliBridge.BridgeCommandException) { throw; } catch (Exception ex) { throw ProBuilderErrors.OutcomeUnknown("delete-faces", "invoke", ex.Message); }
+            try { if (!ProBuilderReflection.RefreshMeshPreservingVertexPayload(mesh)) throw ProBuilderErrors.OutcomeUnknown("delete-faces", "readback", "ProBuilder refresh failed."); EditorSceneManager.MarkSceneDirty(go.scene); var freshMesh = ProBuilderReflection.GetProBuilderMesh(EditorUtility.InstanceIDToObject(id) as GameObject); var after = ProBuilderReflection.GetFaceCount(freshMesh); if (after < 0 || after != before - indices.Length) throw ProBuilderErrors.OutcomeUnknown("delete-faces", "postcondition", "Fresh face count did not confirm deletion."); return new System.Threading.Tasks.ValueTask<Result>(new Result { DeletedCount = indices.Length, RemainingFaceCount = after }); }
+            catch (UnityCliBridge.BridgeCommandException) { throw; } catch (Exception ex) { throw ProBuilderErrors.OutcomeUnknown("delete-faces", "readback", ex.Message); }
+        }
+    }
+}
+#endif

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

@@ -0,0 +1,46 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+namespace UnityCli.ProBuilder
+{
+    public class DetachFacesTool : IUnityCliTool<DetachFacesTool.Request, DetachFacesTool.Result>
+    {
+        public sealed class Request { [UnityCliRequired] public string Target { get; set; } [UnityCliRequired] public List<long> FaceIndices { get; set; } }
+        public sealed class Result { public ObjectRef DetachedObject { get; set; } public long FaceCount { get; set; } }
+        public sealed class ObjectRef { public long Id { get; set; } public string Name { get; set; } public string Path { get; set; } }
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "probuilder.detach-faces",
+            Summary = "Detach selected faces into a new ProBuilder object.",
+            Description = "Detach at least one unique valid face 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 = "分离 strict-domain 面 0", Input = new Request { FaceIndices = new List<long> { 0 }, Target = "TwoIndependentTriangles" } }
+            }
+        };
+        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("detach-faces", "No ProBuilderMesh on target.");
+            var indices = request.FaceIndices?.Select(value => ProBuilderOperationProof.CheckedInt(value, "faceIndices")).ToArray(); var before = ProBuilderReflection.GetFaceCount(mesh); if (indices == null || indices.Length == 0 || indices.Distinct().Count() != indices.Length || before < 1 || ProBuilderReflection.GetFacesByIndices(mesh, indices) == null) throw ProBuilderErrors.SchemaInvalid("faceIndices must contain unique valid faces.");
+            var inverse = Enumerable.Range(0, before).Except(indices).ToArray(); var sourceId = go.GetInstanceID(); ctx.CommitEffect(); GameObject detached = null; var detachedId = 0;
+            var undoGroup = -1;
+            try { Undo.IncrementCurrentGroup(); undoGroup = Undo.GetCurrentGroup(); Undo.SetCurrentGroupName("ProBuilder Detach Faces"); ProBuilderAtomicReadback.RegisterMeshUndo(go, mesh, "ProBuilder Detach Faces", false, go.GetComponent<Renderer>()); detached = UnityEngine.Object.Instantiate(go); detachedId = detached.GetInstanceID(); detached.name = go.name + "_Detached"; Undo.RegisterCreatedObjectUndo(detached, "ProBuilder Detach Faces"); var detachedMesh = ProBuilderReflection.GetProBuilderMesh(detached); if (detachedMesh == null || (inverse.Length > 0 && !ProBuilderReflection.DeleteFaces(detachedMesh, inverse)) || !ProBuilderReflection.DeleteFaces(mesh, indices)) throw ProBuilderErrors.OutcomeUnknown("detach-faces", "invoke", "Face deletion while detaching failed."); if (!ProBuilderReflection.RefreshMesh(mesh) || !ProBuilderReflection.RefreshMesh(detachedMesh)) throw ProBuilderErrors.OutcomeUnknown("detach-faces", "readback", "ProBuilder refresh failed."); }
+            catch (UnityCliBridge.BridgeCommandException) { throw; } catch (Exception ex) { throw ProBuilderErrors.OutcomeUnknown("detach-faces", "invoke", ex.Message); }
+            try { EditorSceneManager.MarkSceneDirty(go.scene); var freshSource = EditorUtility.InstanceIDToObject(sourceId) as GameObject; var freshDetached = EditorUtility.InstanceIDToObject(detachedId) as GameObject; var sourceMesh = ProBuilderReflection.GetProBuilderMesh(freshSource); var detachedMesh = ProBuilderReflection.GetProBuilderMesh(freshDetached); var detachedFaces = ProBuilderReflection.GetFaceCount(detachedMesh); if (freshSource == null || freshDetached == null || freshSource.scene != freshDetached.scene || ProBuilderReflection.GetFaceCount(sourceMesh) != before - indices.Length || detachedFaces != indices.Length || ProBuilderReflection.GetVertexCount(detachedMesh) < 1) throw ProBuilderErrors.OutcomeUnknown("detach-faces", "postcondition", "Fresh source or detached face counts could not be confirmed."); if (undoGroup >= 0) Undo.CollapseUndoOperations(undoGroup); return new System.Threading.Tasks.ValueTask<Result>(new Result { DetachedObject = new ObjectRef { Id = freshDetached.GetInstanceID(), Name = freshDetached.name, Path = HierarchyPath(freshDetached) }, FaceCount = detachedFaces }); }
+            catch (UnityCliBridge.BridgeCommandException) { throw; } catch (Exception ex) { throw ProBuilderErrors.OutcomeUnknown("detach-faces", "readback", ex.Message); }
+        }
+        private static string HierarchyPath(GameObject go) { var names = new Stack<string>(); for (var current = go.transform; current != null; current = current.parent) names.Push(current.name); return string.Join("/", names.ToArray()); }
+    }
+}
+#endif

package/extensions/probuilder/unitypkg/Editor/ProBuilder/duplicate-and-flip.cs

@@ -0,0 +1,100 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.ProBuilder;
+using UnityEngine.ProBuilder.MeshOperations;
+
+namespace UnityCli.ProBuilder
+{
+    /// <summary>
+    /// probuilder.duplicate-and-flip — 复制选定面并翻转法线。
+    /// </summary>
+    public class DuplicateAndFlipTool : IUnityCliTool<DuplicateAndFlipTool.Request, DuplicateAndFlipTool.Result>
+    {
+        public sealed class Request
+        {
+            [UnityCliRequired] public string Target { get; set; }
+            public List<long> FaceIndices { get; set; }             // 可选,空则作用于全部面
+        }
+
+        public sealed class Result
+        {
+            public long DuplicatedCount { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "probuilder.duplicate-and-flip",
+            Summary = "Duplicate selected faces and flip their normals on a ProBuilder mesh.",
+            Description = "Duplicate selected faces and flip their normals with the ProBuilder 5.x AppendElements.DuplicateAndFlip API. When faceIndices is omitted, all faces are used. Complete terminal verification requires a Renderer with non-empty sharedMaterials, valid face submesh indices, and every material slot used by at least one face. UV0 must be complete for every raw vertex or absent for the whole mesh; partial UV0 profiles are rejected.",
+            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 } } }
+            }
+        };
+
+        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(request.Target);
+
+            var mesh = ProBuilderReflection.GetProBuilderMesh(go);
+            if (mesh == null) throw ProBuilderErrors.OperationFailed("duplicate-and-flip", "No ProBuilderMesh on target.");
+            // The canonical snapshot freezes target/component identity before the effect.
+
+            var typedMesh = mesh as ProBuilderMesh;
+            int[] faceIndices = request.FaceIndices?.Select(i => ProBuilderOperationProof.CheckedInt(i, "faceIndices")).ToArray();
+            if (typedMesh == null || typedMesh.faces == null || typedMesh.faces.Count == 0)
+                throw ProBuilderErrors.OperationFailed("duplicate-and-flip", "No faces found on target.");
+            var requestedFaceIndices = faceIndices == null || faceIndices.Length == 0 ? Enumerable.Range(0, typedMesh.faces.Count).ToArray() : faceIndices;
+            // 同一 occurrence 仅消费一次，保留首次请求顺序。
+            requestedFaceIndices = requestedFaceIndices.Distinct().ToArray();
+            ProBuilderOperationProof.ValidateFaceIndices(mesh, requestedFaceIndices);
+            // effect 前按请求顺序冻结 exact occurrence；effect 不得重新解析 index。
+            var frozenFaces = requestedFaceIndices.Select(index => typedMesh.faces[index]).ToArray();
+            var plan = ProBuilderFlipCompletionProof.CaptureDuplicateAndFlip(go, frozenFaces, requestedFaceIndices);
+            if (plan == null) throw ProBuilderErrors.OperationFailed("duplicate-and-flip", "Requested complete terminal state is not readable.");
+            ctx.CommitEffect();
+            try
+            {
+            Undo.RecordObject(go, "ProBuilder Duplicate and Flip");
+            try { AppendElements.DuplicateAndFlip(typedMesh, plan.FrozenFaces); }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch { throw ProBuilderErrors.OutcomeUnknown("duplicate-and-flip", "invoke", "AppendElements.DuplicateAndFlip threw after the effect barrier."); }
+
+            if (!ProBuilderReflection.RefreshMeshPreservingVertexPayload(typedMesh))
+                throw ProBuilderErrors.OutcomeUnknown("duplicate-and-flip", "readback", "ProBuilder mesh payload-preserving refresh failed after the effect.");
+            EditorSceneManager.MarkSceneDirty(go.scene);
+            try
+            {
+                if (!ProBuilderFlipCompletionProof.DuplicateAndFlipMatches(plan, target))
+                    throw ProBuilderErrors.OutcomeUnknown("duplicate-and-flip", "postcondition", "The complete AppendElements.DuplicateAndFlip terminal state was not proven by fresh readback.");
+            }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch (System.Exception)
+            {
+                throw ProBuilderErrors.OutcomeUnknown("duplicate-and-flip", "postcondition", "Duplicate-and-flip terminal-state readback threw after the effect barrier.");
+            }
+
+                return new System.Threading.Tasks.ValueTask<Result>(new Result { DuplicatedCount = plan.FrozenFaces.Length });
+            }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch (System.Exception exception) { throw ProBuilderErrors.OutcomeUnknown("duplicate-and-flip", "postcondition", exception.Message); }
+        }
+    }
+}
+#endif

package/extensions/probuilder/unitypkg/Editor/ProBuilder/extrude-edges.cs

@@ -0,0 +1,118 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+
+namespace UnityCli.ProBuilder
+{
+    /// <summary>
+    /// probuilder.extrude-edges — 挤出 ProBuilder 网格的选定边。
+    /// </summary>
+    public class ExtrudeEdgesTool : IUnityCliTool<ExtrudeEdgesTool.Request, ExtrudeEdgesTool.Result>
+    {
+        public sealed class Request
+        {
+            [UnityCliRequired] public string Target { get; set; }
+            public List<long> EdgeIndices { get; set; }            // 可选
+            public List<EdgeRef> Edges { get; set; }               // 可选
+            public double? Distance { get; set; }                  // 可选,默认 0.5
+            public bool? AsGroup { get; set; }                     // 可选,默认 true
+        }
+
+        public sealed class EdgeRef
+        {
+            public long A { get; set; }
+            public long B { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public long ModifiedEdgeCount { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "probuilder.extrude-edges",
+            Summary = "Extrude selected edges of a ProBuilder mesh by a distance.",
+            Description = "Extrude one or more boundary edges in local space. Specify edges by edgeIndices (indices into the unique edge list) or vertex-pair edges [{a,b}]. Every selected edge must have exactly one readable face incidence; all referenced raw vertices require cached finite normals, UV1 must be absent, every existing triangle requires fully finite 5.2.4 UV0 tangent reciprocal, direction, and raw accumulation arithmetic, distance must be non-zero, and the complete 5.2.4 append terminal must be fully finite and provable before mutation. asGroup defaults to true. Each created side quad receives a deterministic manual UV0 layout before tangent refresh.",
+            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.5 距离", Input = new Request { Target = "MyCube", Edges = new List<EdgeRef> { new EdgeRef { A = 0, B = 1 } }, Distance = 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(request.Target);
+
+            var mesh = ProBuilderReflection.GetProBuilderMesh(go);
+            if (mesh == null) throw ProBuilderErrors.OperationFailed("extrude-edges", "No ProBuilderMesh component on target.");
+
+            var distance = ProBuilderOperationProof.CheckedFloat(request.Distance ?? 0.5, "distance");
+            var asGroup = request.AsGroup ?? true;
+            int[] edgeIndices = request.EdgeIndices?.Select(i => ProBuilderOperationProof.CheckedInt(i, "edgeIndices")).ToArray();
+            ProBuilderInput.EdgePair[] edgePairs = request.Edges?.Select(e => new ProBuilderInput.EdgePair { a = ProBuilderOperationProof.CheckedInt(e.A, "edges.a"), b = ProBuilderOperationProof.CheckedInt(e.B, "edges.b") }).ToArray();
+
+            if ((edgeIndices == null || edgeIndices.Length == 0) && (edgePairs == null || edgePairs.Length == 0))
+                throw ProBuilderErrors.SchemaInvalid("edgeIndices or edges parameter is required for extrude-edges.");
+
+            if (distance == 0f) throw ProBuilderErrors.SchemaInvalid("distance must not be zero.");
+            var edgeArray = ProBuilderOperationProof.ValidateEdges(mesh, edgeIndices, edgePairs);
+            var source = ProBuilderEdgeCompletionProof.Capture(go, mesh, edgeArray);
+            if (!ProBuilderEdgeCompletionProof.TryPlanExtrude(source, distance, asGroup))
+                throw ProBuilderErrors.SchemaInvalid("extrude-edges requires boundary edges, cached finite normals, absent UV1, fully finite 5.2.4 UV0 tangent arithmetic for every existing triangle, and a fully finite provable append plan.");
+            ctx.CommitEffect();
+            try
+            {
+            bool invoked; int edgeCount;
+            try
+            {
+                Undo.RecordObject(go, "ProBuilder Extrude Edges");
+                invoked = ProBuilderReflection.TryExtrudeFrozenEdges(mesh, edgeArray, distance, asGroup, out edgeCount);
+            }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch { throw ProBuilderErrors.OutcomeUnknown("extrude-edges", "invoke", "ProBuilder edge extrusion threw after the effect barrier."); }
+            if (!invoked || edgeCount != edgeArray.Length)
+                throw ProBuilderErrors.OutcomeUnknown("extrude-edges", "invoke", "ProBuilder edge extrusion did not return every frozen requested edge.");
+            if (!ProBuilderOperationProof.ApplyDeterministicQuadUvs(mesh, source[0].Before.Faces.Length, edgeCount))
+                throw ProBuilderErrors.OutcomeUnknown("extrude-edges", "invoke", "The created side quads could not receive their deterministic manual UV0 layout.");
+            try
+            {
+                if (!ProBuilderReflection.RefreshMeshPreservingVertexPayload(mesh)) throw new System.InvalidOperationException();
+                EditorSceneManager.MarkSceneDirty(go.scene);
+            }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch { throw ProBuilderErrors.OutcomeUnknown("extrude-edges", "readback", "ProBuilder mesh refresh failed after effect."); }
+            var freshMesh = ProBuilderEdgeCompletionProof.ResolveFresh(source[0], target);
+            if (freshMesh == null)
+                throw ProBuilderErrors.OutcomeUnknown("extrude-edges", "readback", "Fresh target identity could not be resolved.");
+            try
+            {
+                if (!ProBuilderEdgeCompletionProof.ExtrudeMatches(source, go, freshMesh, distance, asGroup, edgeCount))
+                    throw ProBuilderErrors.OutcomeUnknown("extrude-edges", "postcondition", "Requested outer edges and side faces were not proven by fresh readback.");
+            }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch (System.Exception exception) { throw ProBuilderErrors.OutcomeUnknown("extrude-edges", "postcondition", exception.Message); }
+
+                return new System.Threading.Tasks.ValueTask<Result>(new Result { ModifiedEdgeCount = edgeCount });
+            }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch (System.Exception exception) { throw ProBuilderErrors.OutcomeUnknown("extrude-edges", "postcondition", exception.Message); }
+        }
+    }
+}
+#endif

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

@@ -0,0 +1,110 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.SceneManagement;
+using UnityEngine;
+using UnityEngine.ProBuilder;
+using UnityEngine.ProBuilder.MeshOperations;
+
+namespace UnityCli.ProBuilder
+{
+    /// <summary>
+    /// probuilder.extrude-faces — 挤出 ProBuilder 网格的选定面。
+    /// </summary>
+    public class ExtrudeFacesTool : IUnityCliTool<ExtrudeFacesTool.Request, ExtrudeFacesTool.Result>
+    {
+        public sealed class Request
+        {
+            [UnityCliRequired] public string Target { get; set; }
+            public List<long> FaceIndices { get; set; }             // 可选,空则作用于全部面
+            public double? Distance { get; set; }                  // 可选,默认 0.5
+            public string Method { get; set; }                     // 可选,默认 vertexNormal
+        }
+
+        public sealed class Result
+        {
+            public long ModifiedFaceCount { get; set; }
+            public long NewVertexCount { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "probuilder.extrude-faces",
+            Summary = "Extrude selected faces of a ProBuilder mesh by a distance.",
+            Description = "Extrude the sole triangular face of a strictly isolated ProBuilder mesh by a given distance. The target must contain exactly one non-degenerate triangle with three distinct raw/shared vertices, an explicit shared-texture partition, exactly one occupied renderer material slot at submesh 0, and a predicted cap and side-wall terminal whose positions, normals, and complete 5.2.4 tangent arithmetic stay finite. faceIndices may be omitted or must be [0]. Method is individual, vertexNormal (default), or faceNormal. Each created side quad receives a deterministic manual UV0 layout before tangent refresh.",
+            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 = "MyTriangle", FaceIndices = new List<long> { 0 }, Distance = 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(request.Target);
+
+            var typedMesh = ProBuilderReflection.GetProBuilderMesh(go) as ProBuilderMesh;
+            if (typedMesh == null) throw ProBuilderErrors.OperationFailed("extrude-faces", "No ProBuilderMesh component on target.");
+
+            int[] faceIndices = request.FaceIndices?.Select(i => ProBuilderOperationProof.CheckedInt(i, "faceIndices")).ToArray();
+            var distance = ProBuilderOperationProof.CheckedFloat(request.Distance ?? 0.5, "distance");
+            var method = request.Method ?? "vertexNormal";
+            if (float.IsNaN(distance) || float.IsInfinity(distance) || distance == 0f)
+                throw ProBuilderErrors.SchemaInvalid("distance must be finite and non-zero.");
+            if (faceIndices != null && (faceIndices.Length != 1 || faceIndices[0] != 0))
+                throw ProBuilderErrors.SchemaInvalid("faceIndices must be omitted or exactly [0] for the deterministic extrusion domain.");
+            if (method != "individual" && method != "vertexNormal" && method != "faceNormal")
+                throw ProBuilderErrors.SchemaInvalid("method must be individual, vertexNormal, or faceNormal.");
+
+            var plan = ProBuilderFaceExtrudeCompletionProof.TryCreate(go, typedMesh, new[] { 0 }, method, distance);
+            if (plan == null)
+                throw ProBuilderErrors.SchemaInvalid("extrude-faces requires one isolated non-degenerate triangle, complete finite vertex/shared-texture/material data, and fully finite predicted position, normal, and 5.2.4 tangent arithmetic.");
+
+            ctx.CommitEffect();
+            try
+            {
+                Undo.RecordObject(go, "ProBuilder Extrude Faces");
+                var created = ExtrudeElements.Extrude(typedMesh, plan.FrozenFaces, plan.Method, plan.Distance);
+                if (created == null || created.Length != 3 || !ProBuilderOperationProof.ApplyDeterministicQuadUvs(typedMesh, plan.Before.Faces.Length, created.Length))
+                    throw new InvalidOperationException();
+            }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch { throw ProBuilderErrors.OutcomeUnknown("extrude-faces", "invoke", "ProBuilder 5.2.4 face extrusion threw or did not return three frozen-face side walls."); }
+            try
+            {
+                if (!ProBuilderReflection.RefreshMeshPreservingVertexPayload(typedMesh)) throw new InvalidOperationException();
+                EditorSceneManager.MarkSceneDirty(go.scene);
+            }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch { throw ProBuilderErrors.OutcomeUnknown("extrude-faces", "readback", "ProBuilder mesh payload-preserving refresh failed after effect."); }
+            try
+            {
+                if (!ProBuilderFaceExtrudeCompletionProof.Matches(plan, target))
+                    throw ProBuilderErrors.OutcomeUnknown("extrude-faces", "postcondition", "The complete ProBuilder 5.2.4 face-extrude terminal state was not proven by fresh readback.");
+            }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch { throw ProBuilderErrors.OutcomeUnknown("extrude-faces", "postcondition", "Face-extrude terminal-state readback threw after the effect barrier."); }
+
+            try
+            {
+                return new System.Threading.Tasks.ValueTask<Result>(new Result { ModifiedFaceCount = 1, NewVertexCount = 12 });
+            }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch (System.Exception exception) { throw ProBuilderErrors.OutcomeUnknown("extrude-faces", "postcondition", exception.Message); }
+        }
+    }
+}
+#endif