com.elestrago.unity.package-tools 2.1.0 → 2.2.1

package/CAHNGELOG.md

@@ -2,6 +2,23 @@
 
 ---
 
+## [2.2.1](https://gitlab.com/elestrago-pkg/package-tool/-/tags/2.2.1)
+
+### Added
+
+- Added cleanup of empty ancestor folders under `Assets/Samples/` after the `Claude Skills` post-import hook finishes, so importing the sample leaves no stub `Assets/Samples/<Package>/<Version>/` directories behind.
+
+---
+
+## [2.2.0](https://gitlab.com/elestrago-pkg/package-tool/-/tags/2.2.0)
+
+### Added
+
+- Added post-import hook for the `Claude Skills` sample that moves imported skills into `./.claude/skills` and prompts before overwriting existing skills.
+- Added an AGENT NOTE marker stamped onto the local `README.md` and `CAHNGELOG.md` export artifacts after each `Export Package Source`, pointing edits back to the project-root canonical files.
+
+---
+
 ## [2.1.0](https://gitlab.com/elestrago-pkg/package-tool/-/tags/2.1.0)
 
 ### Added

package/Editor/EditorConstants.cs

@@ -105,6 +105,13 @@ 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}:";

package/Editor/Tools/FileTools.cs

@@ -126,6 +126,7 @@ namespace PackageTool.Tools
 				CopyDocumentationToDirectory(packageManifest);
 				RecursivelyCopyDirectoriesAndFiles(packageManifest, normalizedSourcePath, normalizedDestinationPath);
 				CopySamplesToDirectory(packageManifest);
+				StampLocalDocCopiesForAgents(packageManifest);
 
 				Debug.LogFormat(EditorConstants.PACKAGE_UPDATE_SUCCESS_FORMAT, packageManifest.packageName);
 
@@ -265,6 +266,38 @@ namespace PackageTool.Tools
 			}
 		}
 
+		/// <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,259 @@
+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);
+
+			DeleteSampleAndEmptyAncestors(sampleRootAssetPath);
+		}
+
+		private static void DeleteSampleAndEmptyAncestors(string sampleRootAssetPath)
+		{
+			if (!AssetDatabase.DeleteAsset(sampleRootAssetPath))
+			{
+				Debug.LogWarningFormat(
+					"{0} Could not remove imported sample folder [{1}].",
+					LOG_PREFIX,
+					sampleRootAssetPath);
+				AssetDatabase.Refresh();
+				return;
+			}
+
+			// Walk up Assets/Samples/<Package>/<Version>/<Sample>, removing each ancestor that the
+			// just-deleted sample left empty. Bounded to the Assets/Samples subtree so we never
+			// touch unrelated project folders.
+			var current = GetParentAssetPath(sampleRootAssetPath);
+			while (!string.IsNullOrEmpty(current) && IsWithinSamplesTree(current))
+			{
+				var fullPath = Path.GetFullPath(current);
+				if (!Directory.Exists(fullPath))
+					break;
+				if (Directory.GetFileSystemEntries(fullPath).Length > 0)
+					break;
+				if (!AssetDatabase.DeleteAsset(current))
+					break;
+
+				Debug.LogFormat("{0} Removed empty folder [{1}].", LOG_PREFIX, current);
+				current = GetParentAssetPath(current);
+			}
+
+			AssetDatabase.Refresh();
+		}
+
+		private static string GetParentAssetPath(string assetPath)
+		{
+			if (string.IsNullOrEmpty(assetPath))
+				return null;
+			var lastSlash = assetPath.LastIndexOf('/');
+			return lastSlash <= 0 ? null : assetPath.Substring(0, lastSlash);
+		}
+
+		private static bool IsWithinSamplesTree(string assetPath)
+		{
+			return string.Equals(assetPath, "Assets/Samples", StringComparison.Ordinal)
+				|| assetPath.StartsWith("Assets/Samples/", StringComparison.Ordinal);
+		}
+
+		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
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "com.elestrago.unity.package-tools",
-  "version": "2.1.0",
+  "version": "2.2.1",
   "displayName": "Package Tool",
   "description": "Tool for create unity packages",
   "category": "unity",
   "unity": "2021.3",
   "homepage": "https://gitlab.com/elestrago-pkg/package-tool",
-  "documentationUrl": "https://gitlab.com/elestrago-pkg/package-tool/-/blob/2.1.0/README.md",
-  "changelogUrl": "https://gitlab.com/elestrago-pkg/package-tool/-/blob/2.1.0/CHANGELOG.md",
-  "licensesUrl": "https://gitlab.com/elestrago-pkg/package-tool/-/blob/2.1.0/LICENSE",
+  "documentationUrl": "https://gitlab.com/elestrago-pkg/package-tool/-/blob/2.2.1/README.md",
+  "changelogUrl": "https://gitlab.com/elestrago-pkg/package-tool/-/blob/2.2.1/CHANGELOG.md",
+  "licensesUrl": "https://gitlab.com/elestrago-pkg/package-tool/-/blob/2.2.1/LICENSE",
   "license": "MIT",
   "keywords": [
     "unity",