@aqian0/dsh-unity 0.0.0-stage → 0.1.0

package/skills/shader-graph-create-custom-node/resources/all_hints.hlsl

@@ -0,0 +1,182 @@
+#include "ShaderApiReflectionSupport.hlsl"
+
+namespace Namespace
+{
+    struct CustomStruct
+    {
+        float Value;
+    };
+
+/// <funchints>
+///     <sg:ProviderKey>AllHintsUniqueStableID</sg:ProviderKey>
+///     <sg:DisplayName>All Known Hints</sg:DisplayName>
+///     <sg:ReturnDisplayName>Final Result</sg:ReturnDisplayName>
+///     <sg:SearchCategory>Hints/All</sg:SearchCategory>
+///     <sg:SearchTerms>Features, Reflected, Every, Hint</sg:SearchTerms>
+///     <sg:SearchName>All Hints Search Name</sg:SearchName>
+/// </funchints>
+/// <paramhints name="a">
+///     <sg:DisplayName>Custom Struct Value</sg:DisplayName>
+///     <sg:Default>0.5</sg:Default>
+///     <sg:External>Namespace</sg:External>
+/// </paramhints>
+/// <paramhints name="c3">
+///     <sg:DisplayName>Color 3</sg:DisplayName>
+///     <sg:Color />
+///     <sg:Default>1,1,0</sg:Default>
+/// </paramhints>
+/// <paramhints name="c4">
+///     <sg:DisplayName>Color 4</sg:DisplayName>
+///     <sg:Color />
+///     <sg:Default>1,1,0,1</sg:Default>
+/// </paramhints>
+/// <paramhints name="sc3">
+///     <sg:DisplayName>Static Color 3</sg:DisplayName>
+///     <sg:Color />
+///     <sg:Static />
+///     <sg:Default>1,1,0</sg:Default>
+/// </paramhints>
+/// <paramhints name="sc4">
+///     <sg:DisplayName>Static Color 4</sg:DisplayName>
+///     <sg:Color />
+///     <sg:Static />
+///     <sg:Default>1,1,0,1</sg:Default>
+/// </paramhints>
+/// <paramhints name="d">
+///     <sg:DisplayName>Dropdown</sg:DisplayName>
+///     <sg:Dropdown>OptionA, OptionB, OptionC</sg:Dropdown>
+///     <sg:Default>1</sg:Default>
+/// </paramhints>
+/// <paramhints name="sd">
+///     <sg:DisplayName>Dropdown</sg:DisplayName>
+///     <sg:Dropdown>OptionA, OptionB, OptionC</sg:Dropdown>
+///     <sg:Static />
+///     <sg:Default>2</sg:Default>
+/// </paramhints>
+/// <paramhints name="r">
+///     <sg:DisplayName>Range</sg:DisplayName>
+///     <sg:Range>0, 1</sg:Range>
+///     <sg:Default>0.75</sg:Default>
+/// </paramhints>
+/// <paramhints name="sr">
+///     <sg:DisplayName>Range</sg:DisplayName>
+///     <sg:Static />
+///     <sg:Range>0, 1</sg:Range>
+///     <sg:Default>0.25</sg:Default>
+/// </paramhints>
+/// <paramhints name="sb">
+///     <sg:DisplayName>Toggle</sg:DisplayName>
+///     <sg:Static />
+///     <sg:Default>1</sg:Default>
+/// </paramhints>
+/// <paramhints name="si">
+///     <sg:DisplayName>Integer</sg:DisplayName>
+///     <sg:Static />
+///     <sg:Default>5</sg:Default>
+/// </paramhints>
+UNITY_EXPORT_REFLECTION float3 AllHints(
+    inout CustomStruct a,
+    float3 c3,
+    inout float4 c4,
+    float3 sc3,
+    float4 sc4,
+    inout uint d,
+    uint sd,
+    float r,
+    float sr,
+    bool sb,
+    int si
+)
+{
+    return float3(a.Value, sr, sc4.r);
+}
+
+} // Namespace
+
+/// <funchints>
+///     <sg:ProviderKey>GoodReferables</sg:ProviderKey>
+/// </funchints>
+/// <paramhints name="UV">
+///     <UV/>
+///     <Default>UV2</Default>
+/// </paramhints>
+/// <paramhints name="alsoUV">
+///     <sg:Referable>UV</sg:Referable>
+///     <Default>UV1</Default>
+/// </paramhints>
+/// <paramhints name="Position">
+///     <Position/>
+///     <Default>AbsoluteWorld</Default>
+/// </paramhints>
+/// <paramhints name="Normal">
+///     <Normal/>
+///     <Default>World</Default>
+/// </paramhints>
+/// <paramhints name="Tangent">
+///     <Tangent/>
+///     <Default>Object</Default>
+/// </paramhints>
+/// <paramhints name="Bitangent">
+///     <Bitangent/>
+///     <Default>Tangent</Default>
+/// </paramhints>
+/// <paramhints name="ViewDirection">
+///     <ViewDirection/>
+///     <Default>Screen</Default>
+/// </paramhints>
+/// <paramhints name="VertColor">
+///     <VertexColor/>
+/// </paramhints>
+/// <paramhints name="ScreenPosition">
+///     <ScreenPosition/>
+///     <Default>Pixel</Default>
+/// </paramhints>
+/// <paramhints name="defaultValue">
+///     <Default>1,0,0</Default>
+/// </paramhints>
+UNITY_EXPORT_REFLECTION float3 ReferableGood(float2 UV,
+                                            float2 alsoUV,
+                                            float3 Position,
+                                            float3 Normal,
+                                            float3 Tangent,
+                                            float3 Bitangent,
+                                            float3 ViewDirection,
+                                            float4 VertColor,
+                                            float4 ScreenPosition,
+                                            float3 defaultValue)
+{
+    return float3(1,1,0);
+}
+
+/// <funchints>
+///     <sg:ProviderKey>PrecisionTest</sg:ProviderKey>
+///     <Precision/>
+/// </funchints>
+/// <paramhints name="a">
+///     <Dynamic/>
+/// </paramhints>
+/// <paramhints name="b">
+///     <Dynamic/>
+/// </paramhints>
+/// <paramhints name="c">
+///     <Dynamic/>
+/// </paramhints>
+UNITY_EXPORT_REFLECTION float2 PrecisionTest(float a, half b, out float c)
+{
+    c = a + b;
+    return (a,b);
+}
+
+/// <funchints>
+///     <sg:ProviderKey>LinkageExample</sg:ProviderKey>
+/// </funchints>
+/// <paramhints name="test">
+///     <Linkage>other</Linkage>
+/// </paramhints>
+UNITY_EXPORT_REFLECTION float3 LinkageExample(bool test, float other)
+{
+    if (test)
+        return float3(other, 0, 0);
+    else
+        return float3(0, other, 0);
+}

package/skills/sprite-editor/SECURITY.md

@@ -0,0 +1,16 @@
+# Security notes: sprite-editor
+
+This skill has the agent run C# inside the user's open Unity Editor through `unity command script eval`. Automated skill scanners flag that as a powerful capability. It is intentional, and it is limited by the safeguards below.
+
+## Accepted risks
+
+| Risk | Capability | Why it is accepted |
+|---|---|---|
+| `SEC_POWER_CAP` | Runs C# in the user's open Editor through `unity command script eval` | It only reaches the Editor the user already has open, on their own machine, as that user, so it grants nothing they couldn't do themselves. `script eval` sits behind the Pipeline capability gate. No code fetched from a remote source is run. Where a named `unity command` covers a step, the skill uses that instead of `script eval`. |
+
+## Mitigations
+
+- **Only the user's own Editor.** `unity command script eval` talks to the Editor open on this machine. It can't reach another machine or another user's Editor.
+- **Capability gate.** `script eval` is only available when the project's Pipeline package provides it.
+- **No remote code.** The agent runs C# it writes from this skill's own recipes. Nothing downloaded from outside is executed.
+- **Named commands first.** When a dedicated `unity command` covers a step, the skill uses it instead of `script eval`.

package/skills/sprite-editor/SKILL.md

@@ -0,0 +1,66 @@
+---
+name: sprite-editor
+description: Edits Unity sprite rectangles, borders, pivots, outlines, and slicing by generating C# scripts. Use when the user works with sprite sheets or sprite slicing.
+modes: [agent, ask]
+---
+
+# Sprite Editor
+
+Sprite metadata (rects, borders, pivots, outlines) lives inside the importer, not in a file
+you can edit — reaching it means running C# through a live Editor.
+
+**The `unity-cli` skill owns getting you there** — installing the CLI, confirming a connected
+Editor, adding the project's `com.unity.pipeline` package, telling a genuinely absent Editor
+apart from one stuck in Safe Mode, and discovering the Editor's command catalog. Follow it
+first; don't re-derive any of it here.
+
+Two things it can't know for you:
+
+- **You need `script eval` in particular**, not just a reachable Editor. Confirm it appears in the
+  catalog — its presence depends on the Pipeline package version, not on the CLI.
+- **Never hand-edit a `.meta` file to change sprite metadata.** The importer owns that data
+  and the capability checks below exist to prevent corruption, so an unreachable Editor is a
+  stop, not a cue to improvise.
+
+Run C# through the connected Editor with the `script eval` command. Discover its parameter shape
+from `unity command --format json` rather than assuming one — the inline form is
+`unity command script eval --caller plugin --skill sprite-editor --code '<snippet>'`, and some Pipeline versions also register
+`script eval_file` for running a snippet from a file. **Check the catalog before reaching for
+`script eval_file`; it is frequently absent.** `unity command` defaults to a 30 second timeout.
+
+Generates C# editor scripts to manipulate Unity sprites using ISpriteEditorDataProvider. Works with TextureImporter, PSBImporter, and custom importers.
+
+### Passing C# to `script eval`
+
+`script eval` compiles a **statement block, not a file**. Two consequences, both of which cause a
+compile error rather than a warning:
+
+- **No `using` directives.** The compiler reads `using UnityEngine;` as a resource-disposal
+  statement and rejects it (`CS0210`).
+- **Types must be fully qualified.** A bare `AssetDatabase` or `Volume` does not resolve
+  (`CS0246` / `CS0103`), and a bare `Object` is ambiguous with `object` (`CS0104`).
+
+Where a snippet below is written as a file — with usings, for readability, or because it is
+meant to be saved into the project — qualify the types before passing it to `script eval`.
+
+## Workflow
+
+All generated scripts must follow the Safe Core Pattern in [references/templates.md](references/templates.md), which includes MANDATORY capability checks. NEVER attempt operations if capability checks fail - this prevents data corruption. After execution, verify results in Unity console and Project window.
+
+## Common Operations
+
+**Modify Name/Rect/Border/Pivot:** Update corresponding `SpriteRect` fields (see scripts/SetPivotExample.cs for pivot examples)
+- Requires: `EditSpriteName`, `EditSpriteRect`, `EditBorder`, or `EditPivot`
+
+**Add/Remove/Slice:** Create or filter `SpriteRect` array (see [references/background.md](references/background.md) for Unity 2021.2+ requirements)
+- Requires: `CreateAndDeleteSprite`
+
+**Set Outlines:** Get `ISpriteOutlineDataProvider` → Call `SetOutlines()` with GUID + Vector2 arrays
+
+## Important Notes
+
+- Do NOT use AssetPostprocessor or MenuItem patterns
+- Generate standalone snippets only — no `AssetPostprocessor`, no `MenuItem`
+- **Enum assignments:** Always use enum values and cast to numeric types. Never use raw numbers.
+  - ✅ Correct: `(int)SpriteAlignment.Center`
+  - ❌ Wrong: `1` (magic number)

package/skills/sprite-editor/references/api_reference.md

@@ -0,0 +1,151 @@
+# Unity Sprite Editor API Reference
+
+## Table of Contents
+- [Core Interface: ISpriteEditorDataProvider](#core-interface-ispriteeditordataprovider)
+  - [Properties](#properties)
+  - [Core Methods](#core-methods)
+  - [Callbacks](#callbacks)
+- [Additional Data Providers](#additional-data-providers)
+  - [ISpriteNameFileIdDataProvider](#ispritenamefileiddataprovider)
+  - [ISpriteOutlineDataProvider](#ispriteoutlinedataprovider)
+  - [ISpritePhysicsOutlineDataProvider](#ispritephysicsoutlinedataprovider)
+  - [ISpriteBoneDataProvider](#ispritebonedataprovider)
+  - [ISpriteMeshDataProvider](#ispritemeshdataprovider)
+  - [ITextureDataProvider](#itexturedataprovider)
+  - [ISecondaryTextureDataProvider](#isecondarytexturedataprovider)
+  - [ISpriteFrameEditCapability](#ispriteframeeditcapability)
+- [SpriteRect Properties](#spriterect-properties)
+- [Common Patterns](#common-patterns)
+  - [Modifying Sprite Properties](#modifying-sprite-properties)
+  - [Working with Selection](#working-with-selection)
+- [Version Considerations](#version-considerations)
+
+## Core Interface: ISpriteEditorDataProvider
+
+Main interface for editing sprite data. See [templates.md](templates.md) for the standard initialization and usage pattern.
+
+### Properties
+- `SpriteImportMode spriteImportMode` - How sprite data will be imported
+- `float pixelsPerUnit` - Pixels per unit in world space
+- `UnityObject targetObject` - Object providing the data
+
+### Core Methods
+- `SpriteRect[] GetSpriteRects()` - Returns array of SpriteRect
+- `void SetSpriteRects(SpriteRect[] spriteRects)` - Updates sprite rectangles
+- `void Apply()` - Applies changed data
+- `void InitSpriteEditorDataProvider()` - Initializes the provider
+- `T GetDataProvider<T>()` - Gets additional data providers
+- `bool HasDataProvider(Type type)` - Checks if provider type is supported
+
+### Callbacks
+- `void RegisterDataChangeCallback(Action<ISpriteEditorDataProvider> action)`
+- `void UnregisterDataChangeCallback(Action<ISpriteEditorDataProvider> action)`
+
+## Additional Data Providers
+
+### ISpriteNameFileIdDataProvider
+Maps sprite names to file IDs (required for Unity 2021.2+ when adding/removing sprites).
+
+```csharp
+var nameFileIdProvider = dataProvider.GetDataProvider<ISpriteNameFileIdDataProvider>();
+IEnumerable<SpriteNameFileIdPair> pairs = nameFileIdProvider.GetNameFileIdPairs();
+nameFileIdProvider.SetNameFileIdPairs(updatedPairs);
+```
+
+### ISpriteOutlineDataProvider
+Manages outline data for sprite tessellation.
+
+```csharp
+var outlineProvider = dataProvider.GetDataProvider<ISpriteOutlineDataProvider>();
+List<Vector2[]> outlines = outlineProvider.GetOutlines(spriteGuid);
+outlineProvider.SetOutlines(spriteGuid, newOutlines);
+float tessellation = outlineProvider.GetTessellationDetail(spriteGuid);
+outlineProvider.SetTessellationDetail(spriteGuid, 0.5f); // 0-1 range
+```
+
+### ISpritePhysicsOutlineDataProvider
+Manages physics outlines for Polygon Collider 2D.
+
+```csharp
+var physicsProvider = dataProvider.GetDataProvider<ISpritePhysicsOutlineDataProvider>();
+List<Vector2[]> physicsOutlines = physicsProvider.GetOutlines(spriteGuid);
+physicsProvider.SetOutlines(spriteGuid, newPhysicsOutlines);
+float tessellation = physicsProvider.GetTessellationDetail(spriteGuid);
+physicsProvider.SetTessellationDetail(spriteGuid, 0.5f);
+```
+
+### ISpriteBoneDataProvider
+Manages bone data for 2D animation.
+
+```csharp
+var boneProvider = dataProvider.GetDataProvider<ISpriteBoneDataProvider>();
+List<SpriteBone> bones = boneProvider.GetBones(spriteGuid);
+boneProvider.SetBones(spriteGuid, updatedBones);
+```
+
+### ISpriteMeshDataProvider
+Manages custom sprite mesh data (vertices, indices, edges).
+
+```csharp
+var meshProvider = dataProvider.GetDataProvider<ISpriteMeshDataProvider>();
+Vertex2DMetaData[] vertices = meshProvider.GetVertices(spriteGuid);
+int[] indices = meshProvider.GetIndices(spriteGuid);
+Vector2Int[] edges = meshProvider.GetEdges(spriteGuid);
+
+meshProvider.SetVertices(spriteGuid, newVertices);
+meshProvider.SetIndices(spriteGuid, newIndices);
+meshProvider.SetEdges(spriteGuid, newEdges);
+```
+
+### ITextureDataProvider
+Provides texture data for Sprite Editor.
+
+```csharp
+var textureProvider = dataProvider.GetDataProvider<ITextureDataProvider>();
+Texture2D texture = textureProvider.texture;
+Texture2D preview = textureProvider.previewTexture;
+textureProvider.GetTextureActualWidthAndHeight(out int width, out int height);
+Texture2D readable = textureProvider.GetReadableTexture2D();
+```
+
+### ISecondaryTextureDataProvider
+Manages secondary textures.
+
+```csharp
+var secondaryProvider = dataProvider.GetDataProvider<ISecondaryTextureDataProvider>();
+SecondarySpriteTexture[] textures = secondaryProvider.textures;
+secondaryProvider.textures = newTextures;
+```
+
+### ISpriteFrameEditCapability
+Controls sprite frame editing capabilities.
+
+```csharp
+var capabilityProvider = dataProvider.GetDataProvider<ISpriteFrameEditCapability>();
+EditCapability capability = capabilityProvider.GetEditCapability();
+capabilityProvider.SetEditCapability(newCapability);
+```
+
+## SpriteRect Properties
+
+Key properties that can be modified on `SpriteRect`:
+
+- `string name` - Sprite name
+- `GUID spriteID` - Unique identifier (matches sprite asset's `GetSpriteID()`)
+- `Rect rect` - Position and size in texture
+- `Vector2 pivot` - Pivot point (0-1 range, relative to rect)
+- `SpriteAlignment alignment` - Alignment preset (BottomLeft, Center, Custom, etc.)
+- `Vector4 border` - 9-slice border (left, bottom, right, top)
+
+**Note**: The `spriteID` property matches the GUID returned by calling `GetSpriteID()` on a sprite asset at runtime. This allows matching between editor-time configuration and runtime sprites.
+
+## Common Patterns
+
+See [templates.md](templates.md) for code patterns including:
+- Safe Core Pattern with capability checks
+- Modifying sprite properties
+- Working with selection
+
+## Version Considerations
+
+See [background.md](background.md#version-specific-requirements) for Unity version-specific requirements (ISpriteNameFileIdDataProvider in 2021.2+).

package/skills/sprite-editor/references/background.md

@@ -0,0 +1,112 @@
+# Sprite Editor Background Information
+
+## Table of Contents
+- [Why Use ISpriteEditorDataProvider](#why-use-ispriteeditordataprovider)
+- [Original vs Imported Image Sizes](#original-vs-imported-image-sizes)
+  - [The Critical Distinction](#the-critical-distinction)
+  - [Important Implications](#important-implications)
+  - [Critical for Slicing Operations](#critical-for-slicing-operations)
+- [Importer Compatibility](#importer-compatibility)
+  - [TextureImporter Configuration](#textureimporter-configuration)
+  - [Other Importers](#other-importers)
+  - [Data Provider Initialization](#data-provider-initialization)
+- [Version-Specific Requirements](#version-specific-requirements)
+  - [Unity 2021.2+](#unity-20212)
+  - [Unity 2021.1 and Earlier](#unity-20211-and-earlier)
+
+## Why Use ISpriteEditorDataProvider
+
+**ISpriteEditorDataProvider provides a unified interface** that works across all importer types (TextureImporter, PSBImporter, custom importers). This ensures:
+- Scripts work consistently regardless of importer type
+- Changes are properly communicated to the importer
+- Sprite metadata is handled correctly
+
+**Never access importer-specific properties directly.** Always use ISpriteEditorDataProvider for compatibility.
+
+## Original vs Imported Image Sizes
+
+### The Critical Distinction
+
+**Sprite data is always based on the original image size**, not the imported Texture2D size.
+
+**Original Image Size:**
+- The dimensions of the source image file before import
+- Example: 4096x4096 PNG file
+
+**Imported Texture2D Size:**
+- The actual texture size after import
+- Can be **smaller** due to:
+  - Platform-specific texture size limitations (e.g., mobile max 2048x2048)
+  - Texture compression settings
+  - Max texture size in import settings
+
+### Important Implications
+
+1. **All sprite data uses original coordinates:**
+   - Sprite rectangles (rect)
+   - Borders (for 9-slicing)
+   - Pivots
+   - Outline coordinates
+
+2. **Example:**
+   - Original image: 4096x4096 PNG
+   - Imported texture: 2048x2048 (due to max size setting)
+   - Sprite rect: `(0, 0, 4096, 4096)` ← Still uses original dimensions!
+
+3. **Unity handles scaling internally** when rendering sprites
+
+4. **Always work in original image coordinate space** when editing sprite data
+
+### Critical for Slicing Operations
+
+When performing slicing (automatic, grid, isometric), you **MUST ensure the texture being sliced matches the original source image size**.
+
+If the imported Texture2D is smaller than original:
+- Slicing coordinates will be incorrect
+- Sprite rectangles won't align with intended regions
+- The operation will fail
+
+**Solution:** Use `GetTextureToSlice` utility (see scripts/README.md) to ensure correct texture dimensions for slicing.
+
+## Importer Compatibility
+
+### TextureImporter Configuration
+
+For TextureImporter to support sprites:
+- `textureType` must be `TextureImporterType.Sprite`
+- `spriteImportMode` must be `SpriteImportMode.Multiple` for multiple sprites
+
+The pre-flight check automatically configures these settings.
+
+### Other Importers
+
+PSBImporter and custom importers may have different configuration requirements. Always verify ISpriteEditorDataProvider support before attempting sprite operations.
+
+### Data Provider Initialization
+
+See [templates.md](templates.md) for the standard initialization pattern. If `dataProvider` is null, the importer does not support sprite editing.
+
+## Version-Specific Requirements
+
+### Unity 2021.2+
+
+Adding or removing sprites requires additional steps:
+
+```csharp
+var nameFileIdProvider = dataProvider.GetDataProvider<ISpriteNameFileIdDataProvider>();
+if (nameFileIdProvider != null)
+{
+    // Get existing name-file ID pairs
+    var nameFileIdPairs = nameFileIdProvider.GetNameFileIdPairs();
+
+    // Update pairs when adding/removing sprites
+    // Add new pair: nameFileIdPairs.Add(new SpriteNameFileIdPair(name, fileId));
+    // Remove pair: nameFileIdPairs.RemoveAll(p => p.name == spriteName);
+
+    nameFileIdProvider.SetNameFileIdPairs(nameFileIdPairs);
+}
+```
+
+### Unity 2021.1 and Earlier
+
+ISpriteNameFileIdDataProvider does not exist. Simply use SetSpriteRects() without additional steps.

package/skills/sprite-editor/references/templates.md

@@ -0,0 +1,72 @@
+# Sprite Editor Code Templates
+
+## Safe Core Pattern (MANDATORY)
+
+Types are fully qualified because this runs through `script eval`, which rejects `using` directives.
+If you save it as a `.cs` file instead, add `using UnityEditor.U2D.Sprites;` and shorten them.
+
+Use this structure for all sprite modification tasks.
+
+**CRITICAL:** If capability checks fail, the script MUST return immediately. NEVER bypass capability checks even if you suspect the API might work - this can cause data corruption and violates Unity's data provider contract.
+
+```csharp
+// 1. Get and Init Data Provider
+var importer = UnityEditor.AssetImporter.GetAtPath(assetPath);
+var factory = new UnityEditor.U2D.Sprites.SpriteDataProviderFactories();
+factory.Init();
+var dataProvider = factory.GetSpriteEditorDataProviderFromObject(importer);
+dataProvider.InitSpriteEditorDataProvider();
+
+// 2. MANDATORY: Check Capabilities - ABORT if not supported
+var editCapability = dataProvider.GetDataProvider<UnityEditor.U2D.Sprites.ISpriteFrameEditCapability>();
+if (editCapability == null)
+{
+    throw new System.Exception("Edit capability not supported by importer. Operation aborted.");
+}
+
+var capability = editCapability.GetEditCapability();
+// Check for: EditSpriteName, EditSpriteRect, EditBorder, EditPivot, CreateAndDeleteSprite
+if (!capability.HasCapability(UnityEditor.U2D.Sprites.EEditCapability.EditSpriteName))
+{
+    throw new System.Exception("Operation not supported by importer. User action aborted.");
+}
+
+// 3. Read and Modify
+var spriteRects = dataProvider.GetSpriteRects();
+// ... logic here ...
+
+// 4. Apply and Reimport
+dataProvider.SetSpriteRects(spriteRects);
+dataProvider.Apply();
+importer.SaveAndReimport();
+```
+
+## Capability Check Pattern
+
+Before performing any modification operation, check if the importer supports it. **ABORT the user action if the capability is not supported.**
+
+**DO NOT rationalize bypassing this check.** Even if you believe the API might accept the operation, capability checks are mandatory for data integrity. Return immediately on failure - no exceptions.
+
+```csharp
+var editCapability = dataProvider.GetDataProvider<UnityEditor.U2D.Sprites.ISpriteFrameEditCapability>();
+if (editCapability == null)
+{
+    throw new System.Exception("Edit capability not supported by importer. User action aborted.");
+    return;
+}
+
+var capability = editCapability.GetEditCapability();
+if (!capability.HasCapability(UnityEditor.U2D.Sprites.EEditCapability.EditSpriteName)) // Adjust based on task
+{
+    throw new System.Exception("Importer does not support the requested operation. User action aborted.");
+    return;
+}
+```
+
+### Available Capabilities
+
+- `EditSpriteName` - Modify sprite names
+- `EditSpriteRect` - Modify sprite rectangles
+- `EditBorder` - Modify 9-slice borders
+- `EditPivot` - Modify pivot points
+- `CreateAndDeleteSprite` - Add/remove sprites or perform slicing

package/skills/sprite-editor/scripts/AutomaticSliceTexture.cs

@@ -0,0 +1,40 @@
+using System;
+using UnityEditor.U2D.Sprites;
+
+namespace Editor
+{
+    static public partial class SpriteEditorUtility
+    {
+        /// <summary>
+        /// Automatically slices a texture by detecting visible pixel regions and creating sprite rectangles.
+        /// Uses Unity's internal automatic sprite detection algorithm to find sprite boundaries.
+        /// </summary>
+        /// <param name="spriteDataProvider">The sprite data provider for the texture.</param>
+        /// <param name="textureProvider">The texture data provider.</param>
+        /// <param name="minRectSize">Minimum size in pixels for detected sprite rectangles.</param>
+        /// <param name="extrudeSize">Number of pixels to extrude (expand) sprite boundaries.</param>
+        /// <param name="addNewSpriteMethod">Method for handling existing sprites (DeleteAll, Smart, Safe).</param>
+        /// <param name="nameGenerator">Function to generate sprite names based on index.</param>
+        /// <param name="kOverlapTolerance">Tolerance for detecting overlapping sprites.</param>
+        /// <param name="kBestFitTolerance">Tolerance for best-fit matching.</param>
+        /// <param name="bestFit">Whether to use best-fit algorithm for overlap detection.</param>
+        /// <returns>True if slicing succeeded, false if texture is not readable.</returns>
+        static public bool AutomaticSliceTexture(ISpriteEditorDataProvider spriteDataProvider, ITextureDataProvider textureProvider,
+            int minRectSize, int extrudeSize, AddNewSpriteMethod addNewSpriteMethod, Func<int, string> nameGenerator,
+            float kOverlapTolerance= 0.00001f, float kBestFitTolerance = 0.5f, bool bestFit = false)
+        {
+            var texture = GetTextureToSlice(textureProvider);
+            if (texture == null)
+            {
+                return false;
+            }
+
+            var rects = UnityEditorInternal.InternalSpriteUtility.GenerateAutomaticSpriteRectangles(texture, minRectSize, extrudeSize);
+
+            var newRects = GenerateNewSpriteRects(spriteDataProvider, rects, addNewSpriteMethod, nameGenerator, kOverlapTolerance, kBestFitTolerance, bestFit);
+            spriteDataProvider.SetSpriteRects(newRects.ToArray());
+
+            return true;
+        }
+    }
+}