@alpsckr/unitycli 0.4.0

package/unitypkg/Editor/Tools/diagnose/preflight.cs

@@ -0,0 +1,269 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.IO;
+using System.Linq;
+using System.Reflection;
+using System.Text;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UnityCli
+{
+    public static partial class UnityCliBridge
+    {
+        /// <summary>
+        /// diagnose.preflight — 聚合 Unity Editor 健康诊断。
+        ///
+        /// 作为 UnityCliBridge 的嵌套类实现，聚合 Editor 状态、公开 Tool 计数、项目 Tool
+        /// fingerprint 与编译诊断。所有动态字段直接构造为 Dictionary/List 值树。
+        /// </summary>
+        public sealed class DiagnosePreflightTool : IUnityCliTool<DiagnosePreflightTool.Request, DiagnosePreflightTool.Result>
+        {
+            public sealed class Request
+            {
+                public string Command { get; set; }
+            }
+
+            public sealed class Result
+            {
+                public string TargetCommand { get; set; }
+                public ProjectInfo Project { get; set; }
+                [UnityCliAnyJson] public object Editor { get; set; }
+                public BridgeInfo Bridge { get; set; }
+                public CustomFingerprintInfo CustomTools { get; set; }
+                [UnityCliAnyJson] public List<object> Checks { get; set; }
+            }
+
+            public sealed class ProjectInfo
+            {
+                public string Path { get; set; }
+                public string UnityVersion { get; set; }
+                public string ActiveScene { get; set; }
+            }
+
+            public sealed class BridgeInfo
+            {
+                public bool Ready { get; set; }
+                public long ToolCount { get; set; }
+            }
+
+            public sealed class CustomFingerprintInfo
+            {
+                [UnityCliAnyJson] public object Fingerprint { get; set; }
+            }
+
+            public sealed class CompileStatusCheck
+            {
+                public string Name { get; set; }
+                public bool Ok { get; set; }
+                public bool Compiling { get; set; }
+                public bool ScanComplete { get; set; }
+                public bool HasCompileErrors { get; set; }
+                public long CompileErrorCount { get; set; }
+                public bool CompileErrorsTruncated { get; set; }
+                public List<string> CompileErrors { get; set; }
+                public List<string> NextActions { get; set; }
+            }
+
+            public ToolDescriptor Describe() => new()
+            {
+                Name = "diagnose.preflight",
+                Summary = "Run a live Unity Editor health check for project state, capability counts, custom fingerprints, and compile diagnostics.",
+                Description = "Reads current project and Editor busy state, public Tool counts, custom Tool fingerprint health, and recent compile diagnostics without exposing Bridge routes, ports, or logs.",
+                Group = "diagnose",DestructiveHint = false, Target = "editor", PlayModeSupport = "supported",
+                DefaultTimeoutMs = 30000, MaxTimeoutMs = 600000,
+                Examples = new[]
+                {
+                    new ToolExample { Description = "Run live preflight", Input = new Request { } },
+                    new ToolExample { Description = "Preflight before component work", Input = new Request { Command = "component.add" } }
+                }
+            };
+
+            public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+            {
+                // preflight 只读取已经发布的 registry 快照，不能为了诊断触发 discovery 或写入缓存。
+                var scene = SceneManager.GetActiveScene();
+                var checks = new List<object>
+                {
+                    MakeCheck("unityNotBusy", !(EditorApplication.isCompiling || EditorApplication.isUpdating || BuildPipeline.isBuildingPlayer)),
+                    MakeCheck("sceneLoaded", scene.isLoaded),
+                    MakeCheck("projectToolFingerprint", !ProjectTools.Values.Any(definition => definition.FingerprintStatus == "blocked")),
+                    BuildCompileStatus(ct)
+                };
+
+                return new System.Threading.Tasks.ValueTask<Result>(new Result
+                {
+                    TargetCommand = request.Command,
+                    Project = new ProjectInfo
+                    {
+                        Path = ProjectRoot(),
+                        UnityVersion = Application.unityVersion,
+                        ActiveScene = scene.path
+                    },
+                    Editor = new Dictionary<string, object>
+                    {
+                        { "busy", EditorApplication.isCompiling || EditorApplication.isUpdating || BuildPipeline.isBuildingPlayer },
+                        { "compiling", EditorApplication.isCompiling },
+                        { "updating", EditorApplication.isUpdating },
+                        { "building", BuildPipeline.isBuildingPlayer }
+                    },
+                    Bridge = new BridgeInfo
+                    {
+                        Ready = true,
+                        ToolCount = ProjectTools.Count
+                    },
+                    CustomTools = new CustomFingerprintInfo { Fingerprint = ProjectToolFingerprintSummary() },
+                    Checks = checks
+                });
+            }
+
+            // 构造 {name, ok} 检查项(运行时 Dictionary,UnityCliSerializer 序列化为对象)
+            private static Dictionary<string, object> MakeCheck(string name, bool ok)
+            {
+                return new Dictionary<string, object> { { "name", name }, { "ok", ok } };
+            }
+
+            // 编译状态检查:isCompiling + 近期编译错误(通过反射 LogEntries)。
+            // 扩展编译失败会让 Unity 持续无法完成编译、Bridge 报 E_UNITY_COMPILING,这里把状态和错误明示出来,
+            // 让 doctor 能定位是"扩展编译失败"而非"bridge 不可达"。
+            private static CompileStatusCheck BuildCompileStatus(System.Threading.CancellationToken ct)
+            {
+                const int maxScannedEntries = 5000;
+                const int maxScanMilliseconds = 50;
+                var scanTimer = System.Diagnostics.Stopwatch.StartNew();
+                var compiling = EditorApplication.isCompiling;
+                var hasCompileErrors = false;
+                var scanComplete = true;
+                long compileErrorCount = 0;
+                var compileErrorsTruncated = false;
+                var compileErrorChars = 0;
+                const int maxCompileErrorChars = 64 * 1024;
+                const int maxCompileErrorLineChars = 4096;
+                var errors = new List<string>();
+                try
+                {
+                    var logEntriesType = FindType("UnityEditor.LogEntries") ?? FindType("UnityEditorInternal.LogEntries");
+                    if (logEntriesType != null)
+                    {
+                        var flags = BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic;
+                        var start = logEntriesType.GetMethod("StartGettingEntries", flags);
+                        var end = logEntriesType.GetMethod("EndGettingEntries", flags);
+                        var count = logEntriesType.GetMethod("GetCount", flags);
+                        var getEntry = logEntriesType.GetMethod("GetEntryInternal", flags);
+                        var getLines = logEntriesType.GetMethod("GetLinesAndModeFromEntryInternal", flags)
+                            ?? logEntriesType.GetMethod("GetLinesAndModeInternal", flags);
+                        if ((start == null && count == null) || (getEntry == null && getLines == null)) scanComplete = false;
+                        var total = start != null
+                            ? Convert.ToInt32(start.Invoke(null, Type.EmptyTypes), CultureInfo.InvariantCulture)
+                            : count == null ? 0 : Convert.ToInt32(count.Invoke(null, Type.EmptyTypes), CultureInfo.InvariantCulture);
+                        try
+                        {
+                            var scannedEntries = 0;
+                            for (var i = total - 1; i >= 0; i--)
+                            {
+                                ct.ThrowIfCancellationRequested();
+                                if (scannedEntries >= maxScannedEntries || scanTimer.ElapsedMilliseconds >= maxScanMilliseconds)
+                                {
+                                    scanComplete = false;
+                                    compileErrorsTruncated = true;
+                                    break;
+                                }
+                                scannedEntries++;
+                                string line = null;
+                                var mode = 0;
+                                try
+                                {
+                                    if (getLines != null && getLines.GetParameters().Length == 4)
+                                    {
+                                        var args = new object[] { i, 1, 0, null };
+                                        getLines.Invoke(null, args);
+                                        mode = Convert.ToInt32(args[2], CultureInfo.InvariantCulture);
+                                        line = args[3] as string;
+                                    }
+                                    else if (getEntry != null && getEntry.GetParameters().Length == 4)
+                                    {
+                                        var args = new object[4] { i, null, null, null };
+                                        getEntry.Invoke(null, args);
+                                        line = args[1] as string;
+                                        mode = args[2] == null ? 0 : Convert.ToInt32(args[2], CultureInfo.InvariantCulture);
+                                    }
+                                    else if (getLines != null && getLines.GetParameters().Length == 2)
+                                    {
+                                        var args = new object[] { i, null };
+                                        getLines.Invoke(null, args);
+                                        line = args[1] as string;
+                                    }
+                                }
+                                catch { scanComplete = false; }
+                                if (string.IsNullOrEmpty(line)) { scanComplete = false; continue; }
+                                // 仅关注编译错误(CS####)。mode 位掩码中 bit1 为 error。
+                                var isCompileError = line.IndexOf("CS", StringComparison.OrdinalIgnoreCase) >= 0 && line.IndexOf("error", StringComparison.OrdinalIgnoreCase) >= 0;
+                                if (isCompileError || ((mode & 1) != 0 && line.IndexOf("Compile", StringComparison.OrdinalIgnoreCase) >= 0))
+                                {
+                                    hasCompileErrors = true;
+                                    compileErrorCount++;
+                                    var boundedLine = BoundedUtf8(line, maxCompileErrorLineChars);
+                                    var boundedBytes = Encoding.UTF8.GetByteCount(boundedLine);
+                                    if (errors.Count < 20 && compileErrorChars + boundedBytes <= maxCompileErrorChars)
+                                    {
+                                        errors.Add(boundedLine);
+                                        compileErrorChars += boundedBytes;
+                                        if (boundedLine.Length != line.Length) compileErrorsTruncated = true;
+                                    }
+                                    else compileErrorsTruncated = true;
+                                }
+                            }
+                        }
+                        finally
+                        {
+                            if (start != null && end != null) end.Invoke(null, Type.EmptyTypes);
+                        }
+                    }
+                    else scanComplete = false;
+                }
+                catch (OperationCanceledException) { throw; }
+                catch (Exception exception)
+                {
+                    scanComplete = false;
+                    var readFailure = "Failed to read compile errors: " + exception.GetType().Name;
+                    if (errors.Count < 20 && compileErrorChars + Encoding.UTF8.GetByteCount(readFailure) <= maxCompileErrorChars) errors.Insert(0, readFailure);
+                    else compileErrorsTruncated = true;
+                }
+                if (!scanComplete) compileErrorsTruncated = true;
+                var nextActions = new List<string>();
+                if (!scanComplete) nextActions.Add("Compile diagnostics could not be scanned completely; inspect Unity Console before treating preflight as healthy.");
+                if (hasCompileErrors) nextActions.Add("Review the listed compile errors (often from a broken extension under Packages/com.alpsckr.unitycli/Extensions). Fix or remove the offending extension, then let Unity recompile.");
+                if (compiling) nextActions.Add("Wait for Unity to finish compiling, then re-run doctor.");
+                if (hasCompileErrors && File.Exists(Path.Combine(ProjectRoot(), "Packages", "com.alpsckr.unitycli", "Extensions", "extension.json")))
+                {
+                    nextActions.Add("If an extension no longer compiles, remove it via unitycli extensions remove <id> --project <path>.");
+                }
+                return new CompileStatusCheck
+                {
+                    Name = "compileStatus",
+                    Ok = scanComplete && !compiling && !hasCompileErrors,
+                    Compiling = compiling,
+                    ScanComplete = scanComplete,
+                    HasCompileErrors = hasCompileErrors,
+                    CompileErrorCount = compileErrorCount,
+                    CompileErrorsTruncated = compileErrorsTruncated,
+                    CompileErrors = errors,
+                    NextActions = nextActions
+                };
+            }
+
+            private static string BoundedUtf8(string value, int maxBytes)
+            {
+                if (string.IsNullOrEmpty(value) || Encoding.UTF8.GetByteCount(value) <= maxBytes) return value ?? string.Empty;
+                var length = Math.Min(value.Length, maxBytes);
+                while (length > 0 && Encoding.UTF8.GetByteCount(value.Substring(0, length)) > maxBytes) length--;
+                if (length > 0 && char.IsHighSurrogate(value[length - 1])) length--;
+                return value.Substring(0, length);
+            }
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/editor/EditorActionToolSupport.cs

@@ -0,0 +1,117 @@
+#if UNITY_EDITOR
+using System;
+using System.Linq;
+using UnityEditor;
+
+namespace UnityCli
+{
+    public sealed class PageInfo
+    {
+        public long PageSize { get; set; }
+        public long Cursor { get; set; }
+        public long? NextCursor { get; set; }
+        public long Total { get; set; }
+    }
+
+    public sealed class ResolutionInfo
+    {
+        public long Width { get; set; }
+        public long Height { get; set; }
+        public string FullScreenMode { get; set; }
+    }
+
+    internal static class EditorActionToolSupport
+    {
+        internal sealed class TagLayerChangePlan
+        {
+            internal SerializedObject Serialized { get; set; }
+            internal bool Layer { get; set; }
+            internal bool Add { get; set; }
+            internal string Name { get; set; }
+            internal int Index { get; set; }
+            internal bool Changed { get; set; }
+        }
+
+        /// <summary>只读解析 TagManager、目标元素和可用 layer slot；commit 前完成全部可预见失败。</summary>
+        internal static TagLayerChangePlan PrepareTagLayerChange(bool layer, bool add, string name, int? requestedIndex)
+        {
+            if (string.IsNullOrWhiteSpace(name))
+                throw new UnityCliBridge.BridgeCommandException("E_SCHEMA_INVALID", layer ? "Layer name is required." : "Tag name is required.", "Pass a tag or layer name.");
+            var asset = AssetDatabase.LoadAllAssetsAtPath("ProjectSettings/TagManager.asset").FirstOrDefault();
+            if (asset == null)
+                throw new UnityCliBridge.BridgeCommandException("E_TAG_MANAGER_NOT_FOUND", "Unity TagManager asset was not found.", "Open the project in Unity and retry.");
+            var serialized = new SerializedObject(asset);
+            var property = serialized.FindProperty(layer ? "layers" : "tags");
+            if (property == null)
+                throw new UnityCliBridge.BridgeCommandException("E_TAG_MANAGER_SCHEMA", "Unity TagManager schema was not recognized.", "Use the Unity Editor Project Settings UI.");
+
+            var existingIndex = -1;
+            var start = layer ? 8 : 0;
+            var end = layer ? Math.Min(32, property.arraySize) : property.arraySize;
+            for (var i = start; i < end; i++)
+            {
+                if (property.GetArrayElementAtIndex(i).stringValue == name) { existingIndex = i; break; }
+            }
+            if (existingIndex >= 0)
+                return new TagLayerChangePlan { Serialized = serialized, Layer = layer, Add = add, Name = name, Index = existingIndex, Changed = !add };
+            if (!add)
+                return new TagLayerChangePlan { Serialized = serialized, Layer = layer, Add = false, Name = name, Index = -1, Changed = false };
+            if (!layer)
+                return new TagLayerChangePlan { Serialized = serialized, Layer = false, Add = true, Name = name, Index = property.arraySize, Changed = true };
+
+            var index = requestedIndex ?? -1;
+            if (requestedIndex.HasValue)
+            {
+                if (index < 8 || index >= end)
+                    throw new UnityCliBridge.BridgeCommandException("E_LAYER_INDEX_INVALID", "Layer index must be between 8 and 31.", "Pass an available user layer index.");
+                if (!string.IsNullOrEmpty(property.GetArrayElementAtIndex(index).stringValue))
+                    throw new UnityCliBridge.BridgeCommandException("E_LAYER_SLOT_OCCUPIED", "Layer slot " + index + " is already occupied.", "Pass an empty user layer index or omit index.");
+            }
+            else
+            {
+                for (var i = 8; i < end; i++)
+                {
+                    if (string.IsNullOrEmpty(property.GetArrayElementAtIndex(i).stringValue)) { index = i; break; }
+                }
+            }
+            if (index < 8 || index >= end)
+                throw new UnityCliBridge.BridgeCommandException("E_LAYER_SLOT_UNAVAILABLE", "No user layer slot is available.", "Remove an unused user layer or pass an empty index from 8 through 31.");
+            return new TagLayerChangePlan { Serialized = serialized, Layer = true, Add = true, Name = name, Index = index, Changed = true };
+        }
+
+        /// <summary>执行已验证 plan，并重新读取 TagManager 证明请求状态。</summary>
+        internal static (bool, int) ApplyTagLayerChange(TagLayerChangePlan plan)
+        {
+            var property = plan.Serialized.FindProperty(plan.Layer ? "layers" : "tags");
+            if (plan.Changed)
+            {
+                if (plan.Layer)
+                {
+                    property.GetArrayElementAtIndex(plan.Index).stringValue = plan.Add ? plan.Name : string.Empty;
+                }
+                else if (plan.Add)
+                {
+                    property.InsertArrayElementAtIndex(property.arraySize);
+                    property.GetArrayElementAtIndex(property.arraySize - 1).stringValue = plan.Name;
+                }
+                else
+                {
+                    property.DeleteArrayElementAtIndex(plan.Index);
+                }
+                plan.Serialized.ApplyModifiedProperties();
+            }
+
+            plan.Serialized.Update();
+            property = plan.Serialized.FindProperty(plan.Layer ? "layers" : "tags");
+            var present = false;
+            for (var i = plan.Layer ? 8 : 0; i < (plan.Layer ? Math.Min(32, property.arraySize) : property.arraySize); i++)
+            {
+                if (property.GetArrayElementAtIndex(i).stringValue == plan.Name) { present = true; break; }
+            }
+            if (present != plan.Add)
+                throw new UnityCliBridge.BridgeCommandException("E_TAG_LAYER_STATE_MISMATCH", "TagManager readback did not match the requested state for " + plan.Name + ".", "Inspect Project Settings before retrying.");
+            return (plan.Changed, plan.Layer ? plan.Index : -1);
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/editor/EditorSearchToolSupport.cs

@@ -0,0 +1,146 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using UnityEditor;
+using UnityEditor.Search;
+
+namespace UnityCli
+{
+    /// <summary>Unity Search provider选择、有界同步枚举和portable item投影owner。</summary>
+    internal static class EditorSearchToolSupport
+    {
+        internal const int MaxProviders = 16;
+        internal const int MaxOffset = 10000;
+        internal const int MaxLimit = 200;
+        internal const int MaxQueryLength = 2048;
+        private const int MaxTextLength = 4096;
+
+        internal static EditorSearchResult Search(EditorSearchRequest request)
+        {
+            EditorToolSupport.EnsureEditorNotBusy("editor.search");
+            if (request == null || string.IsNullOrWhiteSpace(request.Query))
+                throw new UnityCliBridge.BridgeCommandException("E_EDITOR_SEARCH_QUERY_REQUIRED", "editor.search requires a non-empty Unity Search query.", "Pass a query such as t:Material or h:Main Camera.");
+            if (request.Query.Length > MaxQueryLength)
+                throw new UnityCliBridge.BridgeCommandException("E_EDITOR_SEARCH_QUERY_TOO_LONG", "Unity Search query exceeds 2048 characters.", "Reduce the query before retrying.");
+            var offset = request.Offset ?? 0L;
+            var limit = request.Limit ?? 50L;
+            if (offset < 0 || offset > MaxOffset)
+                throw new UnityCliBridge.BridgeCommandException("E_EDITOR_SEARCH_PAGE_INVALID", "offset must be between 0 and 10000.", "Use a bounded offset.");
+            if (limit < 1 || limit > MaxLimit)
+                throw new UnityCliBridge.BridgeCommandException("E_EDITOR_SEARCH_PAGE_INVALID", "limit must be between 1 and 200.", "Use a bounded limit.");
+
+            var active = SearchService.GetActiveProviders().Where(provider => provider != null && provider.active).ToList();
+            var byId = active.GroupBy(provider => provider.id, StringComparer.Ordinal).ToDictionary(group => group.Key, group => group.First(), StringComparer.Ordinal);
+            var requested = request.Providers == null || request.Providers.Count == 0
+                ? active.Select(provider => provider.id).Distinct(StringComparer.Ordinal).ToList()
+                : new List<string>(request.Providers);
+            if (requested.Count == 0)
+                throw new UnityCliBridge.BridgeCommandException("E_EDITOR_SEARCH_PROVIDER_NOT_FOUND", "Unity Search has no active providers.", "Open Unity Search and inspect available providers.");
+            if (requested.Count > MaxProviders || requested.Any(string.IsNullOrWhiteSpace) || requested.Distinct(StringComparer.Ordinal).Count() != requested.Count)
+                throw new UnityCliBridge.BridgeCommandException("E_EDITOR_SEARCH_PROVIDER_INVALID", "providers must contain 1..16 unique non-empty exact provider IDs.", "Use provider IDs returned by editor.search provider metadata.");
+            var missing = requested.Where(id => !byId.ContainsKey(id)).ToList();
+            if (missing.Count > 0)
+                throw new UnityCliBridge.BridgeCommandException("E_EDITOR_SEARCH_PROVIDER_NOT_FOUND", "Unity Search provider is not active: " + string.Join(", ", missing) + ".", "Remove unavailable provider IDs or enable them in Unity Search.");
+
+            var results = new List<EditorSearchItem>((int)limit);
+            var matched = 0L;
+            var hasMore = false;
+            SearchContext context = null;
+            ISearchList list = null;
+            try
+            {
+                context = SearchService.CreateContext(requested, request.Query, SearchFlags.Synchronous);
+                list = SearchService.Request(context, SearchFlags.Synchronous);
+                foreach (var item in list)
+                {
+                    if (item == null) continue;
+                    if (matched < offset) { matched++; continue; }
+                    if (results.Count >= limit) { hasMore = true; break; }
+                    results.Add(Item(item));
+                    matched++;
+                }
+            }
+            catch (UnityCliBridge.BridgeCommandException) { throw; }
+            catch (Exception exception)
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_EDITOR_SEARCH_FAILED", "Unity Search failed: " + exception.GetType().Name + ".", "Validate the query and provider IDs before retrying.");
+            }
+            finally
+            {
+                var disposable = list as IDisposable;
+                if (disposable != null) disposable.Dispose();
+                else context?.Dispose();
+            }
+
+            var providers = requested.Select(id => Provider(byId[id])).ToList();
+            return new EditorSearchResult
+            {
+                ReturnedCount = results.Count,
+                HasMore = hasMore,
+                NextOffset = hasMore ? offset + results.Count : (long?)null,
+                Results = results,
+                Providers = providers
+            };
+        }
+
+        private static EditorSearchProvider Provider(SearchProvider provider)
+        {
+            return new EditorSearchProvider
+            {
+                Id = Bound(provider.id),
+                Name = Bound(provider.name),
+                FilterId = Bound(provider.filterId),
+                Priority = provider.priority
+            };
+        }
+
+        private static EditorSearchItem Item(SearchItem item)
+        {
+            string label = null;
+            string description = null;
+            string path = null;
+            try { label = item.GetLabel(item.context, true); } catch { }
+            try { description = item.GetDescription(item.context, true); } catch { }
+            try
+            {
+                var value = item.ToObject();
+                if (value != null) path = AssetDatabase.GetAssetPath(value);
+            }
+            catch { }
+            return new EditorSearchItem
+            {
+                Id = Bound(item.id),
+                Label = Bound(string.IsNullOrEmpty(label) ? item.label ?? item.id : label),
+                Description = Bound(description),
+                ProviderId = Bound(item.provider == null ? null : item.provider.id),
+                Path = Bound(string.IsNullOrEmpty(path) ? null : path),
+                Score = item.score
+            };
+        }
+
+        private static string Bound(string value)
+        {
+            return value == null || value.Length <= MaxTextLength ? value : value.Substring(0, MaxTextLength);
+        }
+    }
+
+    public sealed class EditorSearchProvider
+    {
+        public string Id { get; set; }
+        public string Name { get; set; }
+        public string FilterId { get; set; }
+        public long Priority { get; set; }
+    }
+
+    public sealed class EditorSearchItem
+    {
+        public string Id { get; set; }
+        public string Label { get; set; }
+        public string Description { get; set; }
+        public string ProviderId { get; set; }
+        public string Path { get; set; }
+        public long Score { get; set; }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/editor/EditorToolSupport.cs

@@ -0,0 +1,132 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.Globalization;
+using System.Linq;
+using System.Reflection;
+using UnityEditor;
+using UnityEditorInternal;
+using UnityEngine;
+using UnityEngine.SceneManagement;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// editor/console 域 IUnityCliTool 共享 helper:编辑器状态、PlayMode 控制、
+    /// 菜单执行、Console 读取、标签/层管理。仅供 editor 域自包含工具复用。
+    /// </summary>
+    public static class EditorToolSupport
+    {
+        /// <summary>拦截编译/导入/构建/PlayMode 过渡期的写入请求。</summary>
+        public static void EnsureEditorNotBusy(string command)
+        {
+            if (EditorApplication.isCompiling)
+                throw new UnityCliBridge.BridgeCommandException("E_UNITY_COMPILING", "Unity Editor is compiling scripts.", "Wait for Unity to finish compiling and retry.", transient: true, retryAfterMs: 5000);
+            if (EditorApplication.isUpdating)
+                throw new UnityCliBridge.BridgeCommandException("E_UNITY_IMPORTING", "Unity Editor is importing assets.", "Wait for Unity to finish importing and retry.", transient: true, retryAfterMs: 5000);
+            if (UnityCliBridge.IsPlayModeChanging())
+                throw new UnityCliBridge.BridgeCommandException("E_UNITY_BUSY", "Unity Editor is entering or exiting Play mode.", "Wait for Play mode transition to complete and retry.", transient: true, retryAfterMs: 3000);
+            if (BuildPipeline.isBuildingPlayer)
+                throw new UnityCliBridge.BridgeCommandException("E_UNITY_BUSY", "Unity Editor is building the player.", "Wait for the build to complete and retry.", transient: true, retryAfterMs: 10000);
+        }
+
+        /// <summary>构造编辑器状态 DTO。</summary>
+        public static EditorStateInfo BuildEditorState()
+        {
+            var scene = SceneManager.GetActiveScene();
+            var prefabStage = UnityEditor.SceneManagement.PrefabStageUtility.GetCurrentPrefabStage();
+            return new EditorStateInfo
+            {
+                PlayMode = new PlayModeInfo { IsPlaying = EditorApplication.isPlaying, IsPaused = EditorApplication.isPaused, IsPlayingOrWillChangePlaymode = EditorApplication.isPlayingOrWillChangePlaymode },
+                Busy = new BusyInfo { IsBusy = EditorApplication.isCompiling || EditorApplication.isUpdating || UnityCliBridge.IsPlayModeChanging() || BuildPipeline.isBuildingPlayer, Compiling = EditorApplication.isCompiling, Updating = EditorApplication.isUpdating, Building = BuildPipeline.isBuildingPlayer, PlayModeChanging = UnityCliBridge.IsPlayModeChanging() },
+                ActiveScene = new ActiveSceneInfo { Name = scene.name, Path = scene.path, IsLoaded = scene.isLoaded, IsDirty = scene.isDirty },
+                PrefabStageOpen = prefabStage != null,
+                PrefabStagePath = prefabStage != null ? prefabStage.assetPath : null
+            };
+        }
+
+        /// <summary>读取 Console 日志条目;Unity 2022 通过内部 LogEntries 反射读取。</summary>
+        public static List<ConsoleEntry> ReadConsoleEntries(string typeFilter, string textFilter, int count)
+        {
+            var entries = new List<ConsoleEntry>();
+            var entryType = FindType("UnityEditor.LogEntry");
+            var logEntries = FindType("UnityEditor.LogEntries");
+            var getEntry = logEntries == null ? null : logEntries.GetMethod("GetEntryInternal", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+            if (entryType == null || getEntry == null)
+            {
+                return entries;
+            }
+
+            var entry = Activator.CreateInstance(entryType);
+            var total = ConsoleEntryCount(logEntries);
+            var max = Math.Max(1, Math.Min(count > 0 ? count : 50, 1000));
+            var includeAllTypes = string.IsNullOrEmpty(typeFilter) || string.Equals(typeFilter, "all", StringComparison.OrdinalIgnoreCase);
+            for (var i = total - 1; i >= 0 && entries.Count < max; i--)
+            {
+                getEntry.Invoke(null, new object[] { i, entry });
+                var mode = Convert.ToInt32(entryType.GetField("mode", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetValue(entry), CultureInfo.InvariantCulture);
+                var logType = ConsoleLevel(mode);
+                if (!includeAllTypes && !string.Equals(logType, typeFilter, StringComparison.OrdinalIgnoreCase)) continue;
+                var message = Convert.ToString(entryType.GetField("message", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetValue(entry), CultureInfo.InvariantCulture) ?? "";
+                var file = Convert.ToString(entryType.GetField("file", BindingFlags.Instance | BindingFlags.Public | BindingFlags.NonPublic).GetValue(entry), CultureInfo.InvariantCulture) ?? "";
+                if (!string.IsNullOrEmpty(textFilter)
+                    && message.IndexOf(textFilter, StringComparison.OrdinalIgnoreCase) < 0
+                    && file.IndexOf(textFilter, StringComparison.OrdinalIgnoreCase) < 0) continue;
+                entries.Add(new ConsoleEntry { Type = logType, Message = message, Count = 1 });
+            }
+            return entries;
+        }
+
+        private static int ConsoleEntryCount(Type logEntries)
+        {
+            var method = logEntries == null ? null : logEntries.GetMethod("GetCount", BindingFlags.Static | BindingFlags.Public | BindingFlags.NonPublic);
+            return method == null ? 0 : Convert.ToInt32(method.Invoke(null, null), CultureInfo.InvariantCulture);
+        }
+
+        private static Type FindType(string fullName)
+        {
+            foreach (var assembly in AppDomain.CurrentDomain.GetAssemblies())
+            {
+                Type type = null;
+                try { type = assembly.GetType(fullName, false); } catch { }
+                if (type != null) return type;
+            }
+            return null;
+        }
+
+        // Unity 2022 LogEntry.mode 位布局：kError=1, kAssert=2, kLog=4, kFatal=16, kAssetImportError=64,
+        // kAssetImportWarning=128, kScriptingError=256, kScriptingWarning=512, kScriptingException=2048, kScriptingAssertion=4096。
+        // 错误/警告/断言来自多个位（脚本与资源导入各有独立位），只查低 3 位会把全部条目误归为 log。
+        private static string ConsoleLevel(int mode)
+        {
+            const int errorBits = (1 << 0) | (1 << 4) | (1 << 6) | (1 << 8) | (1 << 11) | (1 << 16);
+            const int warningBits = (1 << 7) | (1 << 9) | (1 << 17);
+            const int assertBits = (1 << 1) | (1 << 12);
+            if ((mode & errorBits) != 0) return "error";
+            if ((mode & assertBits) != 0) return "assert";
+            if ((mode & warningBits) != 0) return "warning";
+            return "log";
+        }
+    }
+
+    // ── editor 域 DTO ──
+
+    public sealed class EditorStateInfo
+    {
+        public PlayModeInfo PlayMode { get; set; }
+        public BusyInfo Busy { get; set; }
+        public ActiveSceneInfo ActiveScene { get; set; }
+        public bool PrefabStageOpen { get; set; }
+        public string PrefabStagePath { get; set; }
+    }
+
+    public sealed class PlayModeInfo { public bool IsPlaying { get; set; } public bool IsPaused { get; set; } public bool IsPlayingOrWillChangePlaymode { get; set; } }
+    public sealed class BusyInfo { public bool IsBusy { get; set; } public bool Compiling { get; set; } public bool Updating { get; set; } public bool Building { get; set; } public bool PlayModeChanging { get; set; } }
+    public sealed class ActiveSceneInfo { public string Name { get; set; } public string Path { get; set; } public bool IsLoaded { get; set; } public bool IsDirty { get; set; } }
+    public sealed class ConsoleEntry { public string Type { get; set; } public string Message { get; set; } public long Count { get; set; } }
+    public sealed class EditorPlannedEffect { public string Type { get; set; } public string Path { get; set; } public string Action { get; set; } public string Name { get; set; } }
+    public sealed class PlayModeResult { public bool Changed { get; set; } public bool IsPlaying { get; set; } public bool IsPaused { get; set; } }
+    public sealed class MenuResult { public string Path { get; set; } public bool Executed { get; set; } public long ElapsedMs { get; set; } }
+    public sealed class TagLayerResult { public string Action { get; set; } public string Name { get; set; } public bool Changed { get; set; } }
+}
+#endif