@alpsckr/unitycli 0.4.0

package/unitypkg/Editor/Tools/texture/create.cs

@@ -0,0 +1,182 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// texture.create — 从源文件或内联生成的纯色纹理创建纹理资产,并可应用导入设置。
+    /// </summary>
+    public class TextureCreateTool : IUnityCliTool<TextureCreateTool.Request, TextureCreateTool.Result>
+    {
+        public sealed class Request
+        {
+            public string Path { get; set; }
+            public string Source { get; set; }
+            public bool? Overwrite { get; set; }
+            public int? Width { get; set; }
+            public int? Height { get; set; }
+            public string Color { get; set; }
+            public string TextureType { get; set; }
+            public bool? Readable { get; set; }
+            public bool? Mipmap { get; set; }
+            public bool? SRGB { get; set; }
+            public bool? AlphaIsTransparency { get; set; }
+            public string WrapMode { get; set; }
+            public string FilterMode { get; set; }
+            public string Compression { get; set; }
+            public int? MaxTextureSize { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public TextureInfo Texture { get; set; }
+            public TextureImportSettings ImportSettings { get; set; }
+            public List<TexturePlannedEffect> PlannedEffects { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "texture.create",
+            Summary = "Create a texture asset from a source file or a generated solid-color image, then apply import settings.",
+            Description = "Create a texture asset at an Assets/ path. With source, copies an existing file (absolute or Assets/ path); otherwise generates a solid-color PNG/JPG from width/height/color. Refuses to overwrite unless overwrite=true. Import settings (textureType/readable/mipmap/sRGB/wrapMode/filterMode/compression/maxTextureSize) are applied after import.",
+            Group = "texture",
+            DestructiveHint = true,
+            SideEffects = new[] { "asset-write", "asset-import" },
+            Target = "editor",
+            PlayModeSupport = "editor-only",
+            DefaultTimeoutMs = 30000,
+            MaxTimeoutMs = 600000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "Generate a 64x64 red texture", Input = new Request { Path = "Assets/Textures/Red.png", Width = 64, Height = 64, Color = "ff0000" } }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            TextureToolSupport.EnsureEditorNotBusy("texture.create");
+            var path = TextureToolSupport.RequireTexturePath(request.Path);
+            var overwrite = request.Overwrite ?? false;
+            TextureToolSupport.ValidateTextureSettings(BuildSettings(request));
+            if (string.IsNullOrEmpty(request.Source) && ((request.Width.HasValue && request.Width.Value <= 0) || (request.Height.HasValue && request.Height.Value <= 0)))
+                throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_RANGE_INVALID", "Generated texture width and height must be positive.", "Pass positive width and height.");
+            var settings = BuildSettings(request);
+            byte[] sourceBytes = null;
+            byte[] generatedBytes = null;
+            if (!string.IsNullOrEmpty(request.Source)) sourceBytes = ReadAndValidateSource(request.Source);
+            else generatedBytes = EncodeGeneratedTexture(path, request);
+            if (AssetToolSupport.AssetExists(path) && !overwrite)
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_OUTPUT_EXISTS", "Texture output already exists: " + path, "Pass --overwrite or choose a different texture asset path.");
+            }
+
+            ctx.CommitEffect();
+            AssetToolSupport.CreateAssetDirectory(path);
+            if (!string.IsNullOrEmpty(request.Source))
+            {
+                CopyTextureSource(sourceBytes, path, overwrite);
+            }
+            else
+            {
+                File.WriteAllBytes(AssetToolSupport.AssetFullPath(path), generatedBytes);
+                AssetDatabase.Refresh();
+            }
+
+            try
+            {
+                AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate);
+                TextureToolSupport.ApplyTextureSettings(TextureToolSupport.RequireTextureImporter(path), settings, true);
+                AssetDatabase.SaveAssets();
+            }
+            catch (UnityCliBridge.BridgeCommandException)
+            {
+                throw;
+            }
+            catch (Exception exception)
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_IMPORT_FAILED", "Failed to import texture: " + path + " (" + exception.Message + ")", "Check texture file contents, importer settings and Unity Console diagnostics.");
+            }
+            var texture = AssetDatabase.LoadAssetAtPath<Texture2D>(path);
+            if (texture == null)
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_IMPORT_FAILED", "Texture import did not produce a Texture2D asset: " + path, "Check texture file contents and Unity Console diagnostics.");
+            }
+            return new System.Threading.Tasks.ValueTask<Result>(new Result
+            {
+                Texture = TextureToolSupport.BuildTextureInfo(path, texture),
+                ImportSettings = TextureToolSupport.BuildTextureImportSettings(TextureToolSupport.RequireTextureImporter(path)),
+                PlannedEffects = new List<TexturePlannedEffect> { new TexturePlannedEffect { Type = "texture.create", Path = path, Refresh = true } }
+            });
+        }
+
+        private static byte[] ReadAndValidateSource(string source)
+        {
+            var sourcePath = AssetToolSupport.NormalizeAssetPath(source);
+            var fullSource = sourcePath.StartsWith("Assets/", StringComparison.OrdinalIgnoreCase) ? AssetToolSupport.AssetFullPath(sourcePath) : Path.GetFullPath(source);
+            if (!File.Exists(fullSource)) throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_SOURCE_NOT_FOUND", "Texture source file not found: " + source, "Pass an existing texture source file.");
+            var bytes = File.ReadAllBytes(fullSource);
+            var decoded = new Texture2D(2, 2, TextureFormat.RGBA32, false);
+            try { if (!ImageConversion.LoadImage(decoded, bytes)) throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_DECODE_FAILED", "Texture source could not be decoded: " + source, "Pass a valid image source file."); }
+            finally { UnityEngine.Object.DestroyImmediate(decoded); }
+            return bytes;
+        }
+
+        private static void CopyTextureSource(byte[] sourceBytes, string destinationPath, bool overwrite)
+        {
+            var fullDestination = AssetToolSupport.AssetFullPath(destinationPath);
+            if (File.Exists(fullDestination) && overwrite)
+            {
+                File.Delete(fullDestination);
+            }
+            File.WriteAllBytes(fullDestination, sourceBytes);
+            AssetDatabase.Refresh();
+        }
+
+        private static byte[] EncodeGeneratedTexture(string path, Request request)
+        {
+            var extension = Path.GetExtension(path).ToLowerInvariant();
+            if (extension != ".png" && extension != ".jpg" && extension != ".jpeg")
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_FORMAT_UNSUPPORTED", "Generated textures can only be written as .png or .jpg: " + path, "Pass --source for other texture formats.");
+            }
+            var width = request.Width ?? 1;
+            var height = request.Height ?? 1;
+            var color = TextureToolSupport.ParseTextureColor(request.Color);
+            var texture = new Texture2D(width, height, TextureFormat.RGBA32, false);
+            try
+            {
+                var pixels = new Color[width * height];
+                for (var index = 0; index < pixels.Length; index++) pixels[index] = color;
+                texture.SetPixels(pixels);
+                texture.Apply();
+                var bytes = extension == ".png" ? texture.EncodeToPNG() : texture.EncodeToJPG(95);
+                return bytes;
+            }
+            finally
+            {
+                UnityEngine.Object.DestroyImmediate(texture);
+            }
+        }
+
+        internal static TextureSettings BuildSettings(Request request)
+        {
+            return new TextureSettings
+            {
+                TextureType = request.TextureType,
+                Readable = request.Readable,
+                Mipmap = request.Mipmap,
+                SRGB = request.SRGB,
+                AlphaIsTransparency = request.AlphaIsTransparency,
+                WrapMode = request.WrapMode,
+                FilterMode = request.FilterMode,
+                Compression = request.Compression,
+                MaxTextureSize = request.MaxTextureSize
+            };
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/texture/delete.cs

@@ -0,0 +1,89 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// texture.delete — 删除纹理资产。destructive,支持 dryRun。
+    /// </summary>
+    public class TextureDeleteTool : IUnityCliTool<TextureDeleteTool.Request, TextureDeleteTool.Result>
+    {
+        public sealed class Request
+        {
+            public string Path { get; set; }
+            public string Target { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public bool? DryRun { get; set; }
+            public TextureInfo Texture { get; set; }
+            public List<TexturePlannedEffect> PlannedEffects { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "texture.delete",
+            Summary = "Delete an Assets/ texture asset; destructive, supports --dry-run preview.",
+            Description = "Delete an Assets/ texture asset through AssetDatabase. Destructive: removes a persisted texture. Supports --dry-run to preview the planned deletion without removing anything.",
+            Group = "texture",
+            DestructiveHint = true,
+            SupportsDryRun = true,
+            SideEffects = new[] { "asset-delete" },
+            Target = "editor",
+            PlayModeSupport = "editor-only",
+            DefaultTimeoutMs = 30000,
+            MaxTimeoutMs = 600000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "Preview deleting a texture", Input = new Request { Path = "Assets/Textures/Old.png" }, Execution = new ToolExampleExecution { DryRun = true } }
+            }
+        };
+
+        public async System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            TextureToolSupport.EnsureEditorNotBusy("texture.delete");
+            var path = TextureToolSupport.ResolveTexturePath(request.Path ?? request.Target);
+            if (ctx.DryRun)
+            {
+                return new Result
+                {
+                    DryRun = true,
+                    Texture = TextureToolSupport.BuildTextureInfo(path, TextureToolSupport.LoadTextureAsset(path)),
+                    PlannedEffects = new List<TexturePlannedEffect> { new TexturePlannedEffect { Type = "texture.delete", Path = path } }
+                };
+            }
+            ctx.CommitEffect();
+            if (!AssetDatabase.DeleteAsset(path))
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_DELETE_FAILED", "Failed to delete texture asset: " + path, "Check Unity Console and file permissions.");
+            }
+            AssetDatabase.Refresh();
+            var fullPath = AssetToolSupport.AssetFullPath(path);
+            var deleted = await ctx.Wait.Until(
+                () => !File.Exists(fullPath)
+                    && !Directory.Exists(fullPath)
+                    && !AssetDatabase.IsValidFolder(path)
+                    && AssetDatabase.LoadMainAssetAtPath(path) == null,
+                TimeSpan.FromMilliseconds(Math.Max(1, ctx.TimeoutMs)),
+                ct);
+            var observedExists = File.Exists(fullPath)
+                || Directory.Exists(fullPath)
+                || AssetDatabase.IsValidFolder(path)
+                || AssetDatabase.LoadMainAssetAtPath(path) != null;
+            if (!deleted || observedExists)
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_DELETE_PROOF_MISSING", "Texture deletion was not observed in the file system and AssetDatabase: " + path, "Inspect Unity Console and file permissions before retrying.");
+            }
+            return new Result
+            {
+                Texture = new TextureInfo { Path = path, SizeBytes = 0 },
+                PlannedEffects = new List<TexturePlannedEffect> { new TexturePlannedEffect { Type = "texture.delete", Path = path } }
+            };
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/texture/generate.cs

@@ -0,0 +1,189 @@
+#if UNITY_EDITOR
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// texture.generate — 生成程序化纹理(solid/gradient/radial/noise/checkerboard/stripes/dots/grid/brick)。
+    /// </summary>
+    public class TextureGenerateTool : IUnityCliTool<TextureGenerateTool.Request, TextureGenerateTool.Result>
+    {
+        public sealed class Request
+        {
+            public string Path { get; set; }
+            public int? Width { get; set; }
+            public int? Height { get; set; }
+            public string Pattern { get; set; }
+            public string Color { get; set; }
+            public string Color2 { get; set; }
+            public int? PatternSize { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public bool? DryRun { get; set; }
+            public long SizeBytes { get; set; }
+            public List<TexturePlannedEffect> PlannedEffects { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "texture.generate",
+            Summary = "Generate a procedural PNG texture (solid/gradient/radial/noise/checkerboard/stripes/dots/grid/brick); destructive, supports --dry-run.",
+            Description = "Generate a procedural PNG texture at an Assets/*.png path. Patterns: solid, gradient (linear along x), radial (center outward), noise (Perlin), checkerboard, stripes, dots, grid, brick. color/color2 lerp endpoints; patternSize controls cell size for the tiled patterns. Destructive: writes a new asset file.",
+            Group = "texture",
+            DestructiveHint = true,
+            SupportsDryRun = true,
+            SideEffects = new[] { "asset-write", "asset-import" },
+            Target = "editor",
+            PlayModeSupport = "editor-only",
+            DefaultTimeoutMs = 30000,
+            MaxTimeoutMs = 600000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "Generate a 128x128 checkerboard", Input = new Request { Path = "Assets/Textures/Checker.png", Width = 128, Height = 128, Pattern = "checkerboard", Color = "ffffff", Color2 = "000000", PatternSize = 16 } }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            TextureToolSupport.EnsureEditorNotBusy("texture.generate");
+            var path = TextureToolSupport.RequireTexturePath(request.Path);
+            if (!path.EndsWith(".png", StringComparison.OrdinalIgnoreCase))
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_PATH_INVALID", "texture.generate requires an Assets/*.png path: " + path, "Pass Assets/Textures/Generated.png.");
+            }
+            var width = request.Width ?? 256;
+            var height = request.Height ?? 256;
+            var pattern = request.Pattern ?? "solid";
+            var patternSize = request.PatternSize ?? 8;
+            ValidateGenerateRequest(width, height, pattern, patternSize);
+            var color1 = ParseColorArg(request.Color, Color.white);
+            var color2 = ParseColorArg(request.Color2, Color.black);
+            if (ctx.DryRun)
+            {
+                return new System.Threading.Tasks.ValueTask<Result>(new Result
+                {
+                    DryRun = true,
+                    PlannedEffects = new List<TexturePlannedEffect> { new TexturePlannedEffect { Type = "texture.generate", Path = path } }
+                });
+            }
+            ctx.CommitEffect();
+            var texture = new Texture2D(width, height, TextureFormat.RGBA32, false);
+            var pixels = new Color32[width * height];
+            for (var y = 0; y < height; y++)
+            {
+                for (var x = 0; x < width; x++)
+                {
+                    pixels[y * width + x] = ComputePixel(pattern, x, y, width, height, color1, color2, patternSize);
+                }
+            }
+            texture.SetPixels32(pixels);
+            texture.Apply();
+            AssetToolSupport.CreateAssetDirectory(path);
+            var bytes = texture.EncodeToPNG();
+            if (bytes == null || bytes.Length == 0)
+            {
+                UnityEngine.Object.DestroyImmediate(texture);
+                throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_GENERATE_FAILED", "Texture encoder returned no PNG bytes: " + path, "Check the requested texture dimensions and retry.");
+            }
+            var fullPath = AssetToolSupport.AssetFullPath(path);
+            File.WriteAllBytes(fullPath, bytes);
+            if (!File.Exists(fullPath) || new FileInfo(fullPath).Length <= 0)
+            {
+                UnityEngine.Object.DestroyImmediate(texture);
+                throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_GENERATE_FAILED", "Generated texture file was not written with content: " + path, "Check destination path and permissions, then retry.");
+            }
+            AssetDatabase.ImportAsset(path, ImportAssetOptions.ForceUpdate | ImportAssetOptions.ForceSynchronousImport);
+            var importedTexture = AssetDatabase.LoadAssetAtPath<Texture2D>(path);
+            UnityEngine.Object.DestroyImmediate(texture);
+            if (importedTexture == null)
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_GENERATE_FAILED", "Generated texture failed to import: " + path, "Inspect Unity import diagnostics and retry.");
+            }
+            var sizeBytes = new FileInfo(fullPath).Length;
+            return new System.Threading.Tasks.ValueTask<Result>(new Result
+            {
+                SizeBytes = sizeBytes,
+                PlannedEffects = new List<TexturePlannedEffect> { new TexturePlannedEffect { Type = "texture.generate", Path = path } }
+            });
+        }
+
+        private static void ValidateGenerateRequest(int width, int height, string pattern, int patternSize)
+        {
+            if (width < 1 || width > 4096 || height < 1 || height > 4096)
+                throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_RANGE_INVALID", "Width and Height must be between 1 and 4096.", "Pass dimensions from 1 through 4096.");
+            if (patternSize < 1)
+                throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_RANGE_INVALID", "PatternSize must be positive.", "Pass a positive patternSize.");
+            var valid = string.Equals(pattern, "solid", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(pattern, "gradient", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(pattern, "radial", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(pattern, "noise", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(pattern, "checkerboard", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(pattern, "stripes", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(pattern, "dots", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(pattern, "grid", StringComparison.OrdinalIgnoreCase) ||
+                string.Equals(pattern, "brick", StringComparison.OrdinalIgnoreCase);
+            if (!valid)
+                throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_PATTERN_INVALID", "Unsupported texture pattern: " + pattern, "Pass solid, gradient, radial, noise, checkerboard, stripes, dots, grid, or brick.");
+        }
+
+        private static Color32 ComputePixel(string pattern, int x, int y, int width, int height, Color32 color1, Color32 color2, int patternSize)
+        {
+            if (string.Equals(pattern, "gradient", StringComparison.OrdinalIgnoreCase)
+                || string.Equals(pattern, "radial", StringComparison.OrdinalIgnoreCase))
+            {
+                // gradient=linear(沿 x), radial=从中心向外
+                var t = string.Equals(pattern, "radial", StringComparison.OrdinalIgnoreCase)
+                    ? Vector2.Distance(new Vector2(x, y), new Vector2(width / 2f, height / 2f)) / Mathf.Max(width, height) * 2f
+                    : (float)x / Mathf.Max(1, width - 1);
+                return Color32.Lerp(color1, color2, Mathf.Clamp01(t));
+            }
+            if (string.Equals(pattern, "noise", StringComparison.OrdinalIgnoreCase))
+            {
+                var n = Mathf.PerlinNoise((float)x / width * 8f, (float)y / height * 8f);
+                return Color32.Lerp(color1, color2, n);
+            }
+            var size = Mathf.Max(1, patternSize);
+            if (string.Equals(pattern, "checkerboard", StringComparison.OrdinalIgnoreCase))
+            {
+                return ((x / size + y / size) % 2 == 0) ? color1 : color2;
+            }
+            if (string.Equals(pattern, "stripes", StringComparison.OrdinalIgnoreCase))
+            {
+                return ((y / size) % 2 == 0) ? color1 : color2;
+            }
+            if (string.Equals(pattern, "dots", StringComparison.OrdinalIgnoreCase))
+            {
+                var cx = x % size;
+                var cy = y % size;
+                var r = size / 2f;
+                return (cx - r) * (cx - r) + (cy - r) * (cy - r) <= r * r ? color2 : color1;
+            }
+            if (string.Equals(pattern, "grid", StringComparison.OrdinalIgnoreCase))
+            {
+                return (x % size == 0 || y % size == 0) ? color2 : color1;
+            }
+            if (string.Equals(pattern, "brick", StringComparison.OrdinalIgnoreCase))
+            {
+                var row = y / size;
+                var offset = (row % 2 == 0) ? 0 : size / 2;
+                return (x + offset) % size == 0 || y % size == 0 ? color2 : color1;
+            }
+            return color1;
+        }
+
+        private static Color32 ParseColorArg(string value, Color32 defaultColor)
+        {
+            if (string.IsNullOrEmpty(value)) return defaultColor;
+            Color color;
+            if (ColorUtility.TryParseHtmlString(value, out color)) return color;
+            throw new UnityCliBridge.BridgeCommandException("E_TEXTURE_COLOR_INVALID", "Texture color must be a hex RGB/RGBA value: " + value, "Pass a value such as #ffffff or #ff00ffff.");
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/texture/import-settings.cs

@@ -0,0 +1,104 @@
+#if UNITY_EDITOR
+using System.Collections.Generic;
+using UnityEditor;
+
+namespace UnityCli
+{
+    /// <summary>
+    /// texture.import-settings — 应用 TextureImporter 设置(textureType/readable/mipmap/wrapMode 等)。
+    /// </summary>
+    public class TextureImportSettingsTool : IUnityCliTool<TextureImportSettingsTool.Request, TextureImportSettingsTool.Result>
+    {
+        public sealed class Request
+        {
+            public string Path { get; set; }
+            public string Target { get; set; }
+            public string TextureType { get; set; }
+            public string Type { get; set; }
+            public bool? Readable { get; set; }
+            public bool? Mipmap { get; set; }
+            public bool? SRGB { get; set; }
+            public bool? AlphaIsTransparency { get; set; }
+            public string WrapMode { get; set; }
+            public string FilterMode { get; set; }
+            public string Compression { get; set; }
+            public int? MaxTextureSize { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public TextureInfo Texture { get; set; }
+            public TextureImportSettings ImportSettings { get; set; }
+            public bool Changed { get; set; }
+            public List<TexturePlannedEffect> PlannedEffects { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "texture.import-settings",
+            Summary = "Apply TextureImporter settings (textureType, readable, mipmap, sRGB, wrap/filter mode, compression, max size) to an Assets/ texture.",
+            Description = "Apply TextureImporter settings to an Assets/ texture. Only fields you provide are changed; unspecified fields keep their current value. Documented enum values: textureType (Default/Sprite/Normal/...), wrapMode (Repeat/Clamp/Mirror/...), filterMode (Point/Bilinear/Trilinear), compression (None/Compressed/CompressedHQ/...).",
+            Group = "texture",
+            DestructiveHint = true,
+            SideEffects = new[] { "asset-import" },
+            Target = "editor",
+            PlayModeSupport = "editor-only",
+            DefaultTimeoutMs = 30000,
+            MaxTimeoutMs = 600000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "Set sprite type and clamp wrap", Input = new Request { Path = "Assets/Textures/Icon.png", TextureType = "Sprite", WrapMode = "Clamp" } }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            TextureToolSupport.EnsureEditorNotBusy("texture.import-settings");
+            var path = TextureToolSupport.ResolveTexturePath(request.Path ?? request.Target);
+            TextureToolSupport.LoadTextureAsset(path);
+            var settings = BuildSettings(request);
+            TextureToolSupport.ValidateTextureSettings(settings);
+            ctx.CommitEffect();
+            bool changed;
+            try
+            {
+                changed = TextureToolSupport.ApplyTextureSettings(TextureToolSupport.RequireTextureImporter(path), settings, true);
+            }
+            catch (UnityCliBridge.BridgeCommandException)
+            {
+                throw;
+            }
+            catch (System.Exception exception)
+            {
+                throw new UnityCliBridge.BridgeCommandException("E_IMPORT_FAILED", "Failed to apply texture import settings: " + path + " (" + exception.Message + ")", "Check TextureImporter settings and Unity Console diagnostics.");
+            }
+            var texture = TextureToolSupport.LoadTextureAsset(path);
+            var effects = new List<TexturePlannedEffect>();
+            if (changed) effects.Add(new TexturePlannedEffect { Type = "texture.import-settings", Path = path });
+            return new System.Threading.Tasks.ValueTask<Result>(new Result
+            {
+                Texture = TextureToolSupport.BuildTextureInfo(path, texture),
+                ImportSettings = TextureToolSupport.BuildTextureImportSettings(TextureToolSupport.RequireTextureImporter(path)),
+                Changed = changed,
+                PlannedEffects = effects
+            });
+        }
+
+        private static TextureSettings BuildSettings(Request request)
+        {
+            return new TextureSettings
+            {
+                TextureType = request.TextureType ?? request.Type,
+                Readable = request.Readable,
+                Mipmap = request.Mipmap,
+                SRGB = request.SRGB,
+                AlphaIsTransparency = request.AlphaIsTransparency,
+                WrapMode = request.WrapMode,
+                FilterMode = request.FilterMode,
+                Compression = request.Compression,
+                MaxTextureSize = request.MaxTextureSize
+            };
+        }
+    }
+}
+#endif

package/unitypkg/Editor/Tools/texture/info.cs

@@ -0,0 +1,50 @@
+#if UNITY_EDITOR
+namespace UnityCli
+{
+    /// <summary>
+    /// texture.info — 读取纹理资产摘要与导入设置。
+    /// </summary>
+    public class TextureInfoTool : IUnityCliTool<TextureInfoTool.Request, TextureInfoTool.Result>
+    {
+        public sealed class Request
+        {
+            public string Path { get; set; }
+            public string Target { get; set; }
+        }
+
+        public sealed class Result
+        {
+            public TextureInfo Texture { get; set; }
+            public TextureImportSettings ImportSettings { get; set; }
+        }
+
+        public ToolDescriptor Describe() => new()
+        {
+            Name = "texture.info",
+            Summary = "Return path, guid, dimensions, format, byte size and TextureImporter settings for an Assets/ texture.",
+            Description = "Return path, guid, name, width, height, format, byte size and the full TextureImporter settings for an Assets/ texture. Read-only; use texture.import-settings to change importer fields and texture.modify to edit pixels.",
+            Group = "texture",
+            DestructiveHint = false,
+            Target = "editor",
+            PlayModeSupport = "supported",
+            DefaultTimeoutMs = 30000,
+            MaxTimeoutMs = 600000,
+            Examples = new[]
+            {
+                new ToolExample { Description = "Inspect a texture", Input = new Request { Path = "Assets/Textures/Icon.png" } }
+            }
+        };
+
+        public System.Threading.Tasks.ValueTask<Result> ExecuteAsync(Request request, UnityCliProjectToolContext ctx, System.Threading.CancellationToken ct = default)
+        {
+            var path = TextureToolSupport.ResolveTexturePath(request.Path ?? request.Target);
+            var texture = TextureToolSupport.LoadTextureAsset(path);
+            return new System.Threading.Tasks.ValueTask<Result>(new Result
+            {
+                Texture = TextureToolSupport.BuildTextureInfo(path, texture),
+                ImportSettings = TextureToolSupport.BuildTextureImportSettings(TextureToolSupport.RequireTextureImporter(path))
+            });
+        }
+    }
+}
+#endif