com.elestrago.unity.package-tools 2.0.11 → 2.2.0

package/Documentation~/samples.md

@@ -0,0 +1,73 @@
+<!-- generated by unity-package-docs; safe to regenerate -->
+
+# Package Tool — Samples
+
+How the sample content in this repository uses the package. Each entry maps a sample file to the package types it exercises, so a reader can recreate the same setup against the public API.
+
+## Sample Layout
+
+```
+Assets/Example/Sample
+├── Prefabs
+│   └── ExamplePrefab.prefab
+└── Scene
+    └── SampleScene.unity
+```
+
+On export, `CopySamplesToDirectory` copies this tree to `Release/Samples~/ExampleSample/`, skipping `.meta` files. The shipped sample is consumable from the Package Manager **Samples** tab on the published package.
+
+## Sample → Package Type Mapping
+
+### `Assets/Example/Sample/Prefabs/ExamplePrefab.prefab`
+
+Kind: prefab
+
+This sample asset references no scripts from the package. It exists as a structural demo (the importing user sees a working Scene/Prefab in the package's Samples tab) rather than as an API exercise.
+
+### `Assets/Example/Sample/Scene/SampleScene.unity`
+
+Kind: scene
+
+This sample asset references no scripts from the package. It exists as a structural demo (the importing user sees a working Scene/Prefab in the package's Samples tab) rather than as an API exercise.
+
+## Reproducing the Sample
+
+The example sample is structural only — there are no MonoBehaviour scripts to instantiate. To reproduce from scratch:
+
+1. Create an empty Unity scene and a primitive prefab; both can live anywhere in `Assets/`.
+2. Create a `PackageManifestConfig` asset via **Assets > Create > JCMG/PackageTools/PackageManifestConfig** and configure `sourcePath`, `packageDestinationPath`, and a [`Sample`](api.md#packagemanifestconfigsample) entry whose `sourcePath` points at the folder holding the scene and prefab.
+3. Click **Export Package Source** on the inspector — `FileTools.CreateOrUpdatePackageSource` runs the export pipeline (see `manual.md` → **Export pipeline**) and the sample folder lands under `packageDestinationPath/Samples~/{folderName}`.
+
+Minimal equivalent in C#:
+
+```csharp
+using PackageTool;
+using PackageTool.Tools;
+using UnityEditor;
+using UnityEngine;
+
+var config = ScriptableObject.CreateInstance<PackageManifestConfig>();
+config.packageName = "com.example.sample";
+config.displayName = "Example Sample Package";
+config.packageVersion = "1.0.0";
+config.unityVersion = "2021.3";
+config.sourcePath = "Assets/Example/Source";
+config.packageDestinationPath = "Release";
+config.samples = new[]
+{
+    new PackageManifestConfig.Sample
+    {
+        sourcePath = "Assets/Example/Sample",
+        displayName = "Example Sample",
+        folderName = "ExampleSample",
+        description = "This is example for check test samples",
+    },
+};
+AssetDatabase.CreateAsset(config, "Assets/Example/PackageManifestConfig.asset");
+FileTools.CreateOrUpdatePackageSource(config);
+```
+
+## Notes
+
+- The `Samples~/` folder name (trailing tilde) is a Unity convention: tilde-suffixed folders are excluded from the AssetDatabase import, so packaged samples don't pollute the consuming project until the user clicks **Import** in the Package Manager.
+- For samples that stage content from outside `Assets/` — e.g. a Claude skill folder, vendored data, or generated output — use a [`CopyEntry`](api.md#packagemanifestconfigcopyentry) with `destinationPath` pointing at the same `sourcePath` your `Sample` declares. The `CopyEntry` step runs first; `CopySamplesToDirectory` then ships the staged content into the package.

package/Editor/Drawers/CopyEntryPropertyDrawer.cs

@@ -0,0 +1,95 @@
+using PackageTool.Tools;
+using UnityEditor;
+using UnityEngine;
+
+namespace PackageTool.Drawers
+{
+	[CustomPropertyDrawer(typeof(PackageManifestConfig.CopyEntry))]
+	internal sealed class CopyEntryPropertyDrawer : PropertyDrawer
+	{
+		private const string SOURCE_PATH_PROPERTY_NAME = "sourcePath";
+		private const string DESTINATION_PATH_PROPERTY_NAME = "destinationPath";
+
+		public override void OnGUI(Rect position, SerializedProperty property, GUIContent label)
+		{
+			var sourceRect = new Rect(position)
+			{
+				height = EditorConstants.FOLDER_PATH_PICKER_HEIGHT
+			};
+
+			var destinationRect = new Rect(sourceRect)
+			{
+				position = new Vector2(position.x, sourceRect.y + sourceRect.height + 2f)
+			};
+
+			DrawSourceRow(sourceRect, property.FindPropertyRelative(SOURCE_PATH_PROPERTY_NAME));
+			DrawDestinationRow(destinationRect, property.FindPropertyRelative(DESTINATION_PATH_PROPERTY_NAME));
+		}
+
+		public override float GetPropertyHeight(SerializedProperty property, GUIContent label)
+			=> EditorConstants.FOLDER_PATH_PICKER_HEIGHT * 2f + 2f;
+
+		private static void DrawSourceRow(Rect rowRect, SerializedProperty pathProperty)
+		{
+			var fieldRect = new Rect(rowRect)
+			{
+				width = rowRect.width - EditorConstants.FOLDER_PATH_PICKER_HEIGHT * 2f
+				                      - EditorConstants.FOLDER_PATH_PICKER_BUFFER
+			};
+
+			EditorGUI.PropertyField(fieldRect, pathProperty, new GUIContent(EditorConstants.COPY_ENTRY_SOURCE_LABEL));
+
+			var filePickerRect = new Rect
+			{
+				position = new Vector2(
+					fieldRect.x + fieldRect.width + EditorConstants.FOLDER_PATH_PICKER_BUFFER,
+					rowRect.y),
+				width = EditorConstants.FOLDER_PATH_PICKER_HEIGHT,
+				height = EditorConstants.FOLDER_PATH_PICKER_HEIGHT
+			};
+
+			var folderPickerRect = new Rect
+			{
+				position = new Vector2(
+					filePickerRect.x + filePickerRect.width,
+					rowRect.y),
+				width = EditorConstants.FOLDER_PATH_PICKER_HEIGHT,
+				height = EditorConstants.FOLDER_PATH_PICKER_HEIGHT
+			};
+
+			GUILayoutTools.DrawFilePicker(
+				filePickerRect,
+				pathProperty,
+				EditorConstants.SELECT_SOURCE_PATH_FILE_PICKER_TITLE);
+			GUILayoutTools.DrawFolderPicker(
+				folderPickerRect,
+				pathProperty,
+				EditorConstants.SELECT_SOURCE_PATH_PICKER_FOLDER_TITLE);
+		}
+
+		private static void DrawDestinationRow(Rect rowRect, SerializedProperty pathProperty)
+		{
+			var fieldRect = new Rect(rowRect)
+			{
+				width = rowRect.width - EditorConstants.FOLDER_PATH_PICKER_HEIGHT
+				                      - EditorConstants.FOLDER_PATH_PICKER_BUFFER
+			};
+
+			EditorGUI.PropertyField(fieldRect, pathProperty, new GUIContent(EditorConstants.COPY_ENTRY_DESTINATION_LABEL));
+
+			var folderPickerRect = new Rect
+			{
+				position = new Vector2(
+					fieldRect.x + fieldRect.width + EditorConstants.FOLDER_PATH_PICKER_BUFFER,
+					rowRect.y),
+				width = EditorConstants.FOLDER_PATH_PICKER_HEIGHT,
+				height = EditorConstants.FOLDER_PATH_PICKER_HEIGHT
+			};
+
+			GUILayoutTools.DrawFolderPicker(
+				folderPickerRect,
+				pathProperty,
+				EditorConstants.SELECT_COPY_DESTINATION_FOLDER_PICKER_TITLE);
+		}
+	}
+}

package/Editor/Drawers/CopyEntryPropertyDrawer.cs.meta

@@ -0,0 +1,2 @@
+fileFormatVersion: 2
+guid: 88c4785ea4243706f9dbebc1dd7a5ae4

package/Editor/EditorConstants.cs

@@ -105,8 +105,21 @@ namespace PackageTool
 		public const string PACKAGE_UPDATE_SUCCESS_FORMAT =
 			"[Package Tools] Successfully updated package source for [{0}].";
 
+		public const string AGENT_LOCKED_FILE_MARKER_FORMAT =
+			"<!--\n" +
+			"AGENT NOTE: This file is auto-generated and locked for direct edits.\n" +
+			"Canonical source: ./{0} (at the project root). Edit that file instead.\n" +
+			"Regenerated from the canonical source on every package export.\n" +
+			"-->\n\n";
+
 		public const string SAMPLES_FOLDER_NAME = "Samples~";
 		public const string SAMPLES_HEADER_LABEL = "Samples";
 		public const string SAMPLES_ELEMENT_LABEL_FORMAT = "Sample {0}:";
+
+		public const string COPY_ENTRIES_HEADER_LABEL = "Copy Entries";
+		public const string COPY_ENTRY_ELEMENT_LABEL_FORMAT = "Copy {0}:";
+		public const string COPY_ENTRY_SOURCE_LABEL = "Source";
+		public const string COPY_ENTRY_DESTINATION_LABEL = "Destination";
+		public const string SELECT_COPY_DESTINATION_FOLDER_PICKER_TITLE = "Select Copy Destination Folder";
 	}
 }

package/Editor/Inspectors/PackageManifestConfigInspector.cs

@@ -37,6 +37,7 @@ namespace PackageTool.Inspectors
 		private ReorderableList _keywordReorderableList;
 		private ReorderableList _dependenciesReorderableList;
 		private ReorderableList _samplesReorderableList;
+		private ReorderableList _copyEntriesReorderableList;
 
 		private const string SOURCE_PATH_PROPERTY_NAME = "sourcePath";
 		private const string DOCUMENTATION_PATH_PROPERTY_NAME = "documentationPath";
@@ -61,6 +62,7 @@ namespace PackageTool.Inspectors
 		private const string VERSION_CONSTANTS_NAMESPACE_PROPERTY_NAME = "versionConstantsNamespace";
 		private const string ID_PROPERTY_NAME = "_id";
 		private const string SAMPLES_PROPERTY_NAME = "samples";
+		private const string COPY_ENTRIES_PROPERTY_NAME = "copyEntries";
 
 		private void OnEnable()
 		{
@@ -109,6 +111,16 @@ namespace PackageTool.Inspectors
 				drawElementCallback = DrawSampleElement,
 				elementHeight = EditorGUIUtility.singleLineHeight * 5f
 			};
+
+			var copyEntriesProp = serializedObject.FindProperty(COPY_ENTRIES_PROPERTY_NAME);
+			_copyEntriesReorderableList = new ReorderableList(
+				serializedObject,
+				copyEntriesProp)
+			{
+				drawHeaderCallback = DrawCopyEntriesHeader,
+				drawElementCallback = DrawCopyEntryElement,
+				elementHeight = EditorConstants.FOLDER_PATH_PICKER_HEIGHT * 2f + 2f
+			};
 		}
 
 		public override void OnInspectorGUI()
@@ -203,6 +215,7 @@ namespace PackageTool.Inspectors
 				EditorGUILayout.Space();
 				// _sourcePathsReorderableList.DoLayoutList();
 				_excludePathsReorderableList.DoLayoutList();
+				_copyEntriesReorderableList.DoLayoutList();
 
 				// Package Source Export
 				using (new EditorGUILayout.HorizontalScope())
@@ -400,5 +413,23 @@ namespace PackageTool.Inspectors
 		}
 
 		#endregion
+
+		#region Copy Entries ReorderableList
+
+		private void DrawCopyEntriesHeader(Rect rect)
+		{
+			EditorGUI.LabelField(rect, EditorConstants.COPY_ENTRIES_HEADER_LABEL, EditorStyles.boldLabel);
+		}
+
+		private void DrawCopyEntryElement(Rect rect, int index, bool isActive, bool isFocused)
+		{
+			EditorGUI.PropertyField(
+				rect,
+				serializedObject.FindProperty(COPY_ENTRIES_PROPERTY_NAME).GetArrayElementAtIndex(index),
+				new GUIContent(string.Format(EditorConstants.COPY_ENTRY_ELEMENT_LABEL_FORMAT, index))
+			);
+		}
+
+		#endregion
 	}
 }

package/Editor/PackageManifestConfig.cs

@@ -82,6 +82,21 @@ namespace PackageTool
 			                         || string.IsNullOrEmpty(folderName);
 		}
 
+		/// <summary>
+		/// Describes a copy operation that mirrors a source file or folder into a destination folder inside the
+		/// project. When the source is a folder, the same-named subfolder of the destination is replaced with the
+		/// source folder's content. When the source is a file, the same-named file inside the destination folder
+		/// is replaced. An empty or non-existent destination path falls back to the project root.
+		/// </summary>
+		[Serializable]
+		public sealed class CopyEntry
+		{
+			public string sourcePath;
+			public string destinationPath;
+
+			public bool IsEmpty() => string.IsNullOrEmpty(sourcePath);
+		}
+
 		/// <summary>
 		/// A unique id for this <see cref="PackageManifestConfig"/> instance.
 		/// </summary>
@@ -162,6 +177,11 @@ namespace PackageTool
 
 		public Sample[] samples;
 
+		/// <summary>
+		/// A collection of additional source-to-destination copy operations performed during export.
+		/// </summary>
+		public CopyEntry[] copyEntries;
+
 		/// <summary>
 		/// A path to the where the VersionConstants.cs file should be created/updated
 		/// </summary>

package/Editor/Tools/FileTools.cs

@@ -122,9 +122,11 @@ namespace PackageTool.Tools
 				// If its a file, copy over it and its meta file if it exists.
 				var normalizedSourcePath = Path.GetFullPath(packageManifest.sourcePath);
 
+				CopyEntriesToProject(packageManifest);
 				CopyDocumentationToDirectory(packageManifest);
 				RecursivelyCopyDirectoriesAndFiles(packageManifest, normalizedSourcePath, normalizedDestinationPath);
 				CopySamplesToDirectory(packageManifest);
+				StampLocalDocCopiesForAgents(packageManifest);
 
 				Debug.LogFormat(EditorConstants.PACKAGE_UPDATE_SUCCESS_FORMAT, packageManifest.packageName);
 
@@ -192,6 +194,110 @@ namespace PackageTool.Tools
 			File.Copy(normalizedSourcePath, destinationPath);
 		}
 
+		/// <summary>
+		/// Stages each configured <see cref="PackageManifestConfig.CopyEntry"/> into the project before the
+		/// rest of the export runs. A folder source's content is merged directly into
+		/// <see cref="PackageManifestConfig.CopyEntry.destinationPath"/> (same-named files are overwritten,
+		/// unrelated files in the destination are left alone). A file source overwrites
+		/// <c>destination/{filename}</c>. A blank destination resolves to the project root; a non-blank
+		/// destination that does not yet exist is created. Missing sources log a warning and are skipped.
+		/// </summary>
+		public static void CopyEntriesToProject(PackageManifestConfig packageManifest)
+		{
+			var entries = packageManifest.copyEntries;
+			if (entries == null || entries.Length == 0)
+				return;
+
+			foreach (var entry in entries)
+			{
+				if (entry.IsEmpty())
+					continue;
+
+				var normalizedSourcePath = Path.GetFullPath(entry.sourcePath);
+				var destinationDirectory = ResolveDestinationDirectory(entry.destinationPath);
+
+				if (!Directory.Exists(destinationDirectory))
+					Directory.CreateDirectory(destinationDirectory);
+
+				if (!Directory.Exists(normalizedSourcePath) && !File.Exists(normalizedSourcePath))
+				{
+					Debug.LogWarningFormat(
+						"[Package Tools] Copy entry source [{0}] does not exist, skipping.",
+						entry.sourcePath);
+					continue;
+				}
+
+				if (Directory.Exists(normalizedSourcePath))
+				{
+					CopyDirectoryRecursively(normalizedSourcePath, destinationDirectory);
+				}
+				else if (File.Exists(normalizedSourcePath))
+				{
+					var sourceName = Path.GetFileName(normalizedSourcePath);
+					var targetPath = Path.Combine(destinationDirectory, sourceName);
+
+					if (File.Exists(targetPath))
+						File.Delete(targetPath);
+
+					File.Copy(normalizedSourcePath, targetPath);
+				}
+			}
+		}
+
+		private static string ResolveDestinationDirectory(string rawDestinationPath)
+		{
+			if (string.IsNullOrEmpty(rawDestinationPath))
+				return EditorConstants.ProjectPath;
+
+			return Path.GetFullPath(rawDestinationPath);
+		}
+
+		private static void CopyDirectoryRecursively(string normalizedSourcePath, string normalizedDestinationPath)
+		{
+			var directoryInfo = new DirectoryInfo(normalizedSourcePath);
+
+			foreach (var sdi in directoryInfo.GetDirectories(EditorConstants.WILDCARD_FILTER, SearchOption.AllDirectories))
+				Directory.CreateDirectory(sdi.FullName.Replace(normalizedSourcePath, normalizedDestinationPath));
+
+			foreach (var fi in directoryInfo.GetFiles(EditorConstants.WILDCARD_FILTER, SearchOption.AllDirectories))
+			{
+				var newPath = fi.FullName.Replace(normalizedSourcePath, normalizedDestinationPath);
+				File.Copy(fi.FullName, newPath, overwrite: true);
+			}
+		}
+
+		/// <summary>
+		/// Prepends an HTML-comment AGENT NOTE to the markdown documentation copies under
+		/// <c>sourcePath</c> so any tool or agent that opens the local artifact sees it is locked
+		/// and is pointed at the canonical project-root file. Runs after the recursive copy to
+		/// <c>packageDestinationPath</c>, so the shipped package in <c>Release/</c> stays unstamped
+		/// and consumers never see the note. Plain-text companions like <c>LICENSE</c> are skipped —
+		/// a comment prefix would visibly modify the legal notice.
+		/// </summary>
+		private static void StampLocalDocCopiesForAgents(PackageManifestConfig packageManifest)
+		{
+			var sourceDirectory = Path.GetFullPath(packageManifest.sourcePath);
+			StampMarkdownCopy(sourceDirectory, packageManifest.readmePath);
+			StampMarkdownCopy(sourceDirectory, packageManifest.changelogPath);
+		}
+
+		private static void StampMarkdownCopy(string sourceDirectory, string canonicalRelativePath)
+		{
+			if (string.IsNullOrEmpty(canonicalRelativePath))
+				return;
+			if (!canonicalRelativePath.EndsWith(".md", StringComparison.OrdinalIgnoreCase))
+				return;
+
+			var fileName = Path.GetFileName(canonicalRelativePath);
+			var localCopyPath = Path.Combine(sourceDirectory, fileName);
+			if (!File.Exists(localCopyPath))
+				return;
+
+			var marker = string.Format(EditorConstants.AGENT_LOCKED_FILE_MARKER_FORMAT, canonicalRelativePath);
+			var existing = File.ReadAllText(localCopyPath);
+			File.WriteAllText(localCopyPath, marker + existing);
+		}
+
 		private static void CopySamplesToDirectory(PackageManifestConfig packageManifest)
 		{
 			var samples = packageManifest.samples;

package/Samples~/ClaudeSkills/Editor/ClaudeSkillsPostImport.cs

@@ -0,0 +1,213 @@
+using System;
+using System.Collections.Generic;
+using System.IO;
+using UnityEditor;
+using UnityEngine;
+
+namespace PackageTool.Samples.ClaudeSkills
+{
+	/// <summary>
+	/// Runs once after the "Claude Skills" sample is imported into a consumer project. Walks every
+	/// skill subfolder next to this script, copies it to <c>&lt;project&gt;/.claude/skills/&lt;name&gt;</c>,
+	/// prompting before overwriting an existing skill, and then deletes the imported sample folder so
+	/// the operation does not repeat on subsequent domain reloads.
+	/// </summary>
+	[InitializeOnLoad]
+	internal static class ClaudeSkillsPostImport
+	{
+		private const string LOG_PREFIX = "[Claude Skills]";
+		private const string SKILLS_DESTINATION_RELATIVE = ".claude/skills";
+		private const string EDITOR_FOLDER_NAME = "Editor";
+		private const string SCRIPT_FILE_NAME = "ClaudeSkillsPostImport.cs";
+		private const string DIALOG_TITLE = "Claude Skills";
+		private const string SESSION_GUARD_KEY_PREFIX = "PackageTool.ClaudeSkillsPostImport.Processed:";
+		private const string SESSION_RUNNING_KEY = "PackageTool.ClaudeSkillsPostImport.Running";
+
+		static ClaudeSkillsPostImport()
+		{
+			EditorApplication.delayCall += Run;
+		}
+
+		private static void Run()
+		{
+			// Re-entrancy guard. Multiple copies of this type (e.g. in side-by-side sample imports
+			// each shipping their own assembly) would each schedule a delayCall; without this guard
+			// they would race on the same sample folders and double-prompt the user.
+			if (SessionState.GetBool(SESSION_RUNNING_KEY, false))
+				return;
+			SessionState.SetBool(SESSION_RUNNING_KEY, true);
+
+			try
+			{
+				foreach (var sampleRootAssetPath in FindSampleRootAssetPaths())
+				{
+					// Only run from an imported sample location; never act on the source folder
+					// inside a package author's project.
+					if (!sampleRootAssetPath.StartsWith("Assets/Samples/", StringComparison.Ordinal))
+						continue;
+
+					var guardKey = SESSION_GUARD_KEY_PREFIX + sampleRootAssetPath;
+					if (SessionState.GetBool(guardKey, false))
+						continue;
+					SessionState.SetBool(guardKey, true);
+
+					ProcessSample(sampleRootAssetPath);
+				}
+			}
+			catch (Exception e)
+			{
+				Debug.LogErrorFormat("{0} Post-import failed: {1}", LOG_PREFIX, e);
+			}
+			finally
+			{
+				SessionState.SetBool(SESSION_RUNNING_KEY, false);
+			}
+		}
+
+		private static IEnumerable<string> FindSampleRootAssetPaths()
+		{
+			var suffix = "/" + EDITOR_FOLDER_NAME + "/" + SCRIPT_FILE_NAME;
+			var guids = AssetDatabase.FindAssets("ClaudeSkillsPostImport t:MonoScript");
+			var seen = new HashSet<string>(StringComparer.Ordinal);
+			foreach (var guid in guids)
+			{
+				var path = AssetDatabase.GUIDToAssetPath(guid);
+				if (string.IsNullOrEmpty(path) || !path.EndsWith(suffix, StringComparison.Ordinal))
+					continue;
+
+				var sampleRoot = path.Substring(0, path.Length - suffix.Length);
+				if (seen.Add(sampleRoot))
+					yield return sampleRoot;
+			}
+		}
+
+		private static void ProcessSample(string sampleRootAssetPath)
+		{
+			var projectRoot = ResolveProjectRoot();
+			var skillsRoot = Path.Combine(projectRoot, SKILLS_DESTINATION_RELATIVE);
+			var fullSampleRoot = Path.GetFullPath(sampleRootAssetPath);
+
+			if (!Directory.Exists(fullSampleRoot))
+			{
+				Debug.LogWarningFormat("{0} Sample folder not found at [{1}].", LOG_PREFIX, fullSampleRoot);
+				return;
+			}
+
+			if (!Directory.Exists(skillsRoot))
+				Directory.CreateDirectory(skillsRoot);
+
+			Debug.LogFormat(
+				"{0} Installing skills from [{1}] into [{2}].",
+				LOG_PREFIX,
+				sampleRootAssetPath,
+				ToProjectRelative(skillsRoot, projectRoot));
+
+			var installed = 0;
+			var replaced = 0;
+			var skipped = 0;
+
+			foreach (var skillSource in Directory.GetDirectories(fullSampleRoot))
+			{
+				var skillName = Path.GetFileName(skillSource);
+				if (string.Equals(skillName, EDITOR_FOLDER_NAME, StringComparison.Ordinal))
+					continue;
+
+				var skillTarget = Path.Combine(skillsRoot, skillName);
+				if (Directory.Exists(skillTarget))
+				{
+					var replace = EditorUtility.DisplayDialog(
+						DIALOG_TITLE,
+						string.Format(
+							"Skill \"{0}\" already exists at {1}.\n\nReplace it with the imported version?",
+							skillName,
+							ToProjectRelative(skillTarget, projectRoot)),
+						"Replace",
+						"Skip");
+
+					if (!replace)
+					{
+						Debug.LogFormat("{0} Skipped \"{1}\" (already exists).", LOG_PREFIX, skillName);
+						skipped++;
+						continue;
+					}
+
+					Directory.Delete(skillTarget, recursive: true);
+					replaced++;
+				}
+				else
+				{
+					installed++;
+				}
+
+				CopySkillDirectory(skillSource, skillTarget);
+
+				Debug.LogFormat(
+					"{0} Installed \"{1}\" -> {2}.",
+					LOG_PREFIX,
+					skillName,
+					ToProjectRelative(skillTarget, projectRoot));
+			}
+
+			Debug.LogFormat(
+				"{0} Done. Installed: {1}, Replaced: {2}, Skipped: {3}.",
+				LOG_PREFIX, installed, replaced, skipped);
+
+			AssetDatabase.DeleteAsset(sampleRootAssetPath);
+			AssetDatabase.Refresh();
+		}
+
+		private static void CopySkillDirectory(string source, string destination)
+		{
+			Directory.CreateDirectory(destination);
+
+			foreach (var dir in Directory.GetDirectories(source, "*", SearchOption.AllDirectories))
+			{
+				var relative = MakeRelative(source, dir);
+				Directory.CreateDirectory(Path.Combine(destination, relative));
+			}
+
+			foreach (var file in Directory.GetFiles(source, "*", SearchOption.AllDirectories))
+			{
+				// Skip Unity meta files; the destination lives outside Assets/ and doesn't need them.
+				if (file.EndsWith(".meta", StringComparison.OrdinalIgnoreCase))
+					continue;
+
+				var relative = MakeRelative(source, file);
+				var targetPath = Path.Combine(destination, relative);
+				var targetDir = Path.GetDirectoryName(targetPath);
+				if (!string.IsNullOrEmpty(targetDir))
+					Directory.CreateDirectory(targetDir);
+
+				File.Copy(file, targetPath, overwrite: true);
+			}
+		}
+
+		private static string MakeRelative(string root, string fullPath)
+		{
+			var rel = fullPath.Substring(root.Length);
+			return rel.TrimStart(Path.DirectorySeparatorChar, Path.AltDirectorySeparatorChar);
+		}
+
+		private static string ResolveProjectRoot()
+		{
+			const string assetsSuffix = "/Assets";
+			var dataPath = Application.dataPath;
+			if (dataPath.EndsWith(assetsSuffix, StringComparison.Ordinal))
+				return dataPath.Substring(0, dataPath.Length - assetsSuffix.Length);
+
+			var parent = Directory.GetParent(dataPath);
+			return parent != null ? parent.FullName : dataPath;
+		}
+
+		private static string ToProjectRelative(string fullPath, string projectRoot)
+		{
+			var normalized = fullPath.Replace('\\', '/');
+			var rootNormalized = projectRoot.Replace('\\', '/');
+			if (!normalized.StartsWith(rootNormalized, StringComparison.Ordinal))
+				return normalized;
+
+			var rel = normalized.Substring(rootNormalized.Length).TrimStart('/');
+			return string.IsNullOrEmpty(rel) ? "." : rel;
+		}
+	}
+}

package/Samples~/ClaudeSkills/Editor/Playdarium.PackageTool.Samples.ClaudeSkills.Editor.asmdef

@@ -0,0 +1,16 @@
+{
+    "name": "Playdarium.PackageTool.Samples.ClaudeSkills.Editor",
+    "rootNamespace": "",
+    "references": [],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": false,
+    "precompiledReferences": [],
+    "autoReferenced": true,
+    "defineConstraints": [],
+    "versionDefines": [],
+    "noEngineReferences": false
+}