com.elestrago.unity.package-tools 2.5.2 → 2.5.3

package/Editor/Tools/CIResultModel.cs

@@ -0,0 +1,107 @@
+using System.Collections.Generic;
+using System.IO;
+using Newtonsoft.Json;
+using UnityEngine;
+
+namespace PackageTool.Tools
+{
+	/// <summary>
+	/// The outcome of processing a single <see cref="PackageManifestConfig"/> during a command-line run.
+	/// Serialized to the file passed in the 'resultpath' argument so that callers do not have to parse the
+	/// Unity log.
+	/// </summary>
+	internal sealed class CIResultModel
+	{
+		[JsonProperty("selector")] public string Selector;
+		[JsonProperty("configId")] public string ConfigId;
+		[JsonProperty("configName")] public string ConfigName;
+		[JsonProperty("packageName")] public string PackageName;
+		[JsonProperty("packageVersion")] public string PackageVersion;
+		[JsonProperty("success")] public bool Success;
+		[JsonProperty("packageSourcePath")] public string PackageSourcePath;
+		[JsonProperty("legacyPackagePath")] public string LegacyPackagePath;
+		[JsonProperty("versionConstantsPath")] public string VersionConstantsPath;
+		[JsonProperty("error")] public string Error;
+
+		public static CIResultModel CreateForConfig(string selector, PackageManifestConfig config)
+		{
+			return new CIResultModel
+			{
+				Selector = selector,
+				ConfigId = config.Id,
+				ConfigName = config.name,
+				PackageName = config.packageName,
+				PackageVersion = config.packageVersion,
+				Success = true
+			};
+		}
+
+		public static CIResultModel CreateFailure(string selector, string error)
+		{
+			return new CIResultModel
+			{
+				Selector = selector,
+				Success = false,
+				Error = error
+			};
+		}
+	}
+
+	/// <summary>
+	/// Describes a <see cref="PackageManifestConfig"/> in the project for command-line callers.
+	/// </summary>
+	internal sealed class CIConfigModel
+	{
+		[JsonProperty("id")] public string Id;
+		[JsonProperty("name")] public string Name;
+		[JsonProperty("packageName")] public string PackageName;
+		[JsonProperty("displayName")] public string DisplayName;
+		[JsonProperty("packageVersion")] public string PackageVersion;
+		[JsonProperty("sourcePath")] public string SourcePath;
+		[JsonProperty("packageDestinationPath")] public string PackageDestinationPath;
+		[JsonProperty("legacyPackageDestinationPath")] public string LegacyPackageDestinationPath;
+
+		public static CIConfigModel CreateFromConfig(PackageManifestConfig config)
+		{
+			return new CIConfigModel
+			{
+				Id = config.Id,
+				Name = config.name,
+				PackageName = config.packageName,
+				DisplayName = config.displayName,
+				PackageVersion = config.packageVersion,
+				SourcePath = config.sourcePath,
+				PackageDestinationPath = config.packageDestinationPath,
+				LegacyPackageDestinationPath = config.legacyPackageDestinationPath
+			};
+		}
+	}
+
+	/// <summary>
+	/// Helper methods for writing command-line result files.
+	/// </summary>
+	internal static class CIResultTools
+	{
+		private const string WRITE_ERROR_FORMAT = "[Package Tools] Could not write the result file to [{0}]:\n\n{1}";
+
+		public static void WriteResultFile<T>(string resultPath, IReadOnlyList<T> results)
+		{
+			if (string.IsNullOrEmpty(resultPath))
+				return;
+
+			try
+			{
+				var fullPath = Path.GetFullPath(resultPath);
+				var directoryPath = Path.GetDirectoryName(fullPath);
+				if (!string.IsNullOrEmpty(directoryPath) && !Directory.Exists(directoryPath))
+					Directory.CreateDirectory(directoryPath);
+
+				File.WriteAllText(fullPath, JsonConvert.SerializeObject(results, Formatting.Indented));
+			}
+			catch (System.Exception e)
+			{
+				Debug.LogErrorFormat(WRITE_ERROR_FORMAT, resultPath, e);
+			}
+		}
+	}
+}

package/Editor/Tools/CIResultModel.cs.meta

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 57ebe53cd55744cd937151bfe4b7ed2b
+MonoImporter:
+  externalObjects: {}
+  serializedVersion: 2
+  defaultReferences: []
+  executionOrder: 0
+  icon: {instanceID: 0}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/Editor/Tools/CodeGenTools.cs

@@ -111,12 +111,16 @@ internal static class VersionConstants
 		private const string NO_PATH_SPECIFIED = "A path must be specified for the VersionConstants.cs file to be written " +
 		                                         "to, otherwise this file will not be created.";
 
-		public static void GenerateVersionConstants(PackageManifestConfig config)
+		/// <summary>
+		/// Writes the VersionConstants.cs file for <paramref name="config"/> and returns its path, or null
+		/// when the config has no output path set.
+		/// </summary>
+		public static string GenerateVersionConstants(PackageManifestConfig config)
 		{
 			if(string.IsNullOrEmpty(config.versionConstantsPath))
 			{
 				Debug.LogWarning(NO_PATH_SPECIFIED);
-				return;
+				return null;
 			}
 
 			// Create folder/file path info
@@ -140,6 +144,8 @@ internal static class VersionConstants
 
 			var importPath = Path.Combine(config.versionConstantsPath, FILENAME);
 			AssetDatabase.ImportAsset(importPath);
+
+			return importPath;
 		}
 	}
 }

package/Editor/Tools/FileTools.cs

@@ -53,11 +53,38 @@ namespace PackageTool.Tools
 
 		/// <summary>
 		/// Creates or updates the existing package contents of <see cref="PackageManifestConfig"/>
-		/// <paramref name="packageManifest"/>.
+		/// <paramref name="packageManifest"/>. Failures are logged rather than thrown; callers that need to
+		/// know the outcome should use <see cref="CreateOrUpdatePackageSourceOrThrow"/> instead.
 		/// </summary>
 		/// <param name="packageManifest"></param>
 		public static void CreateOrUpdatePackageSource(PackageManifestConfig packageManifest)
 		{
+			try
+			{
+				CreateOrUpdatePackageSourceOrThrow(packageManifest);
+			}
+			catch (Exception ex)
+			{
+				Debug.LogErrorFormat(EditorConstants.PACKAGE_UPDATE_ERROR_FORMAT, packageManifest.packageName);
+				Debug.LogErrorFormat(packageManifest, ex.ToString());
+			}
+		}
+
+		/// <summary>
+		/// Creates or updates the existing package contents of <see cref="PackageManifestConfig"/>
+		/// <paramref name="packageManifest"/> and returns the path of the written package.json in the
+		/// destination folder. Any failure is thrown to the caller.
+		/// </summary>
+		/// <param name="packageManifest"></param>
+		public static string CreateOrUpdatePackageSourceOrThrow(PackageManifestConfig packageManifest)
+		{
+			if (packageManifest == null)
+				throw new ArgumentNullException(nameof(packageManifest));
+
+			if (string.IsNullOrEmpty(packageManifest.packageDestinationPath))
+				throw new InvalidOperationException(
+					string.Format(EditorConstants.NO_PACKAGE_DESTINATION_PATH_ERROR_FORMAT, packageManifest.name));
+
 			if (!Application.isBatchMode)
 			{
 				EditorUtility.DisplayProgressBar(EditorConstants.PROGRESS_BAR_TITLE, string.Empty, 0f);
@@ -65,35 +92,11 @@ namespace PackageTool.Tools
 
 			try
 			{
-				// Created the folders up to the package json path and then create/import the package.json file.
-				// Its important to have the package.json in the Unity project so that it will have a meta file
-				// Packages without meta files cause warnings/errors when imported.
-				var packageManifestAssetPath = AssetDatabase.GetAssetPath(packageManifest);
-				var parentManifestParentFolderAssetPath = packageManifestAssetPath
-					.Replace(packageManifest.name, string.Empty)
-					.Replace(EditorConstants.ASSET_EXTENSION, string.Empty);
-				var generatedFolderAssetPath = Path.Combine(parentManifestParentFolderAssetPath,
-					EditorConstants.GENERATED_FOLDER_NAME);
-				var fullGeneratedFolderAssetPath = Path.GetFullPath(generatedFolderAssetPath);
-
-				if (!Directory.Exists(fullGeneratedFolderAssetPath))
-				{
-					Directory.CreateDirectory(fullGeneratedFolderAssetPath);
-				}
-
-				var packageJsonFolderAssetPath = Path.Combine(generatedFolderAssetPath, packageManifest.Id);
-				var fullPackageJsonFolderAssetPath = Path.GetFullPath(packageJsonFolderAssetPath);
-				if (!Directory.Exists(fullPackageJsonFolderAssetPath))
-				{
-					Directory.CreateDirectory(fullPackageJsonFolderAssetPath);
-				}
-
-				var packageJsonAssetPath =
-					Path.Combine(packageJsonFolderAssetPath, EditorConstants.PACKAGE_JSON_FILENAME);
-				var fullPackageJsonAssetPath = Path.GetFullPath(packageJsonAssetPath);
-
-				File.WriteAllText(fullPackageJsonAssetPath, packageManifest.GenerateJson());
-				AssetDatabase.ImportAsset(packageJsonAssetPath, ImportAssetOptions.ForceUpdate);
+				// The package.json is written into the package source folder so that it lives in the Unity
+				// project and gets a meta file. Packages without meta files cause warnings/errors when
+				// imported, and keeping it in the source folder means both the package source export and the
+				// legacy package export pick it up along with the rest of the source content.
+				WritePackageJsonToSource(packageManifest);
 
 				// If the directory exists, delete its contents or make the directory.
 				if (Directory.Exists(packageManifest.packageDestinationPath))
@@ -105,17 +108,6 @@ namespace PackageTool.Tools
 					Directory.CreateDirectory(packageManifest.packageDestinationPath);
 				}
 
-				// Copy over the package json and meta file
-				var destinationPackageJsonPath =
-					Path.Combine(packageManifest.packageDestinationPath, EditorConstants.PACKAGE_JSON_FILENAME);
-				File.Copy(fullPackageJsonAssetPath, destinationPackageJsonPath);
-
-				var packageJsonMetaPath = string.Format(EditorConstants.META_FORMAT, fullPackageJsonAssetPath);
-
-				File.Copy(packageJsonMetaPath,
-					Path.Combine(packageManifest.packageDestinationPath,
-						string.Format(EditorConstants.META_FORMAT, EditorConstants.PACKAGE_JSON_FILENAME)));
-
 				// Copy over all directory and file content from source to destination.
 				var normalizedDestinationPath = Path.GetFullPath(packageManifest.packageDestinationPath);
 
@@ -128,17 +120,17 @@ namespace PackageTool.Tools
 				CopySamplesToDirectory(packageManifest);
 				StampLocalDocCopiesForAgents(packageManifest);
 
+				var destinationPackageJsonPath =
+					Path.Combine(packageManifest.packageDestinationPath, EditorConstants.PACKAGE_JSON_FILENAME);
+
 				Debug.LogFormat(EditorConstants.PACKAGE_UPDATE_SUCCESS_FORMAT, packageManifest.packageName);
 
 				if (!Application.isBatchMode)
 				{
 					EditorUtility.RevealInFinder(destinationPackageJsonPath);
 				}
-			}
-			catch (Exception ex)
-			{
-				Debug.LogErrorFormat(EditorConstants.PACKAGE_UPDATE_ERROR_FORMAT, packageManifest.packageName);
-				Debug.LogErrorFormat(packageManifest, ex.ToString());
+
+				return destinationPackageJsonPath;
 			}
 			finally
 			{
@@ -150,6 +142,44 @@ namespace PackageTool.Tools
 			}
 		}
 
+		/// <summary>
+		/// Writes the generated package.json of <paramref name="packageManifest"/> into its
+		/// <see cref="PackageManifestConfig.sourcePath"/> and imports it so a meta file is created for it.
+		/// Returns the project-relative asset path of the written file.
+		/// </summary>
+		/// <param name="packageManifest"></param>
+		public static string WritePackageJsonToSource(PackageManifestConfig packageManifest)
+		{
+			if (packageManifest == null)
+				throw new ArgumentNullException(nameof(packageManifest));
+
+			if (string.IsNullOrEmpty(packageManifest.sourcePath))
+				throw new InvalidOperationException(
+					string.Format(EditorConstants.NO_SOURCE_PATH_ERROR_FORMAT, packageManifest.name));
+
+			var packageJsonAssetPath = Path.Combine(packageManifest.sourcePath, EditorConstants.PACKAGE_JSON_FILENAME);
+			var fullPackageJsonPath = Path.GetFullPath(packageJsonAssetPath);
+			var fullSourcePath = Path.GetFullPath(packageManifest.sourcePath);
+
+			if (!Directory.Exists(fullSourcePath))
+				Directory.CreateDirectory(fullSourcePath);
+
+			File.WriteAllText(fullPackageJsonPath, packageManifest.GenerateJson());
+			AssetDatabase.ImportAsset(packageJsonAssetPath, ImportAssetOptions.ForceUpdate);
+
+			// Imports are deferred while an AssetDatabase.StartAssetEditing scope is open, which can leave the
+			// meta file missing when the export copies the source folder over to the destination.
+			if (!File.Exists(string.Format(EditorConstants.META_FORMAT, fullPackageJsonPath)))
+			{
+				AssetDatabase.Refresh();
+
+				if (!File.Exists(string.Format(EditorConstants.META_FORMAT, fullPackageJsonPath)))
+					Debug.LogWarningFormat(EditorConstants.PACKAGE_JSON_META_MISSING_FORMAT, packageJsonAssetPath);
+			}
+
+			return packageJsonAssetPath;
+		}
+
 		public static void CopyDocumentationToDirectory(PackageManifestConfig packageManifest)
 		{
 			var normalizedSourcePath = Path.GetFullPath(packageManifest.sourcePath);

package/Editor/Tools/UnityFileTools.cs

@@ -22,6 +22,7 @@ OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
 SOFTWARE.
 */
 
+using System;
 using System.Collections.Generic;
 using System.IO;
 using System.Linq;
@@ -37,11 +38,22 @@ namespace PackageTool.Tools
 	{
 		/// <summary>
 		/// Gather all of the files/folders for the package and export them to the pre-defined location
-		/// at <see cref="PackageManifestConfig.legacyPackageDestinationPath"/>.
+		/// at <see cref="PackageManifestConfig.legacyPackageDestinationPath"/>. Returns the path of the
+		/// exported unity package.
 		/// </summary>
 		/// <param name="config"></param>
-		public static void CompileLegacyPackage(PackageManifestConfig config)
+		public static string CompileLegacyPackage(PackageManifestConfig config)
 		{
+			if (config == null)
+				throw new ArgumentNullException(nameof(config));
+
+			if (string.IsNullOrEmpty(config.legacyPackageDestinationPath))
+				throw new InvalidOperationException(
+					string.Format(EditorConstants.NO_LEGACY_DESTINATION_PATH_ERROR_FORMAT, config.name));
+
+			// Written before the documentation copy so its trailing AssetDatabase.Refresh imports the
+			// package.json, which otherwise would not be part of the exported asset paths.
+			FileTools.WritePackageJsonToSource(config);
 			FileTools.CopyDocumentationToDirectory(config);
 
 			// Gathers all of the files/folders for export as a legacy package.
@@ -72,6 +84,8 @@ namespace PackageTool.Tools
 				EditorUtility.RevealInFinder(finalFilePath);
 				EditorUtility.ClearProgressBar();
 			}
+
+			return finalFilePath;
 		}
 
 		/// <summary>

package/README.md

@@ -29,7 +29,7 @@ Add the package to `Packages/manifest.json`:
     }
   ],
   "dependencies": {
-    "com.elestrago.unity.package-tools": "2.5.2"
+    "com.elestrago.unity.package-tools": "2.5.3"
   }
 }
 ```
@@ -43,17 +43,26 @@ Replace the registry URL above with your scoped registry, or remove the `scopedR
 3. Optionally add `dependencies`, `samples`, and `copyEntries` rows in the inspector.
 4. Click **Export Package Source** to assemble the package; **Export as Legacy Package** to emit a `.unitypackage`; or **Generate VersionConstants.cs** to write a versions file at `versionConstantsPath`.
 
-For CI, invoke `PackageTool.CIUtils.Generate` in batch mode and pass `version=<semver>` to override the asset's version on a per-run basis:
+To export from your own editor code, call `PackageTool.PackageToolApi` — the same methods the inspector buttons use:
 
 ```csharp
-// Unity batch-mode CLI:
-// unity -batchmode -quit -projectPath . \
-//   -executeMethod PackageTool.CIUtils.Generate \
-//   version=1.2.3 generateversionconstants=true
-
 using PackageTool;
 
-CIUtils.Generate();
+// Selectors match the config id, the package name, or the config asset name.
+var config = PackageToolApi.GetConfig("com.elestrago.unity.package-tools");
+
+PackageToolApi.ExportPackageSource(config, version: "1.2.3");
+PackageToolApi.ExportLegacyPackage(config);
+```
+
+For CI, invoke the `PackageTool.CIUtils` entry points in batch mode. `Generate` exports both outputs for every config; `ExportPackageSource`, `ExportLegacyPackage` and `ListConfigs` are the narrower entry points. Pass `resultpath=<file>` to get a JSON report instead of scraping the log:
+
+```bash
+unity -batchmode -quit -projectPath . \
+  -executeMethod PackageTool.CIUtils.ExportPackageSource \
+  id=com.elestrago.unity.package-tools \
+  version=1.2.3 \
+  resultpath=/tmp/package-tool-result.json
 ```
 
 ## Documentation

package/Samples~/ClaudeSkills/unity-package-docs/SKILL.md

@@ -71,7 +71,12 @@ find . -type f -name package.json \
 
 - **Exactly one match** → that file is the package manifest. Its containing directory is the **package root**. Read it.
 - **Zero matches but `Assets/**/PackageManifestConfig.asset` exists** (package-tool projects pre-first-export) → use the config asset as the metadata source. The `sourcePath` field is the package root. Note in `manual.md` that the `package.json` is generated to `<packageDestinationPath>/` on export.
-- **More than one match, or zero matches with no config** → abort. Print the matches found and ask the user to disambiguate via `package=<path>`.
+- **More than one match** → a package-tool project exports a copy of `package.json` into its
+  `packageDestinationPath` (e.g. `Release/`), so the same package is legitimately found twice. If exactly one
+  match lies under `Assets/`, that one is the package root and the others are export artifacts — use it and
+  print `package-root: <path> (ignored N exported copy/copies)`. Otherwise abort: print the matches found and
+  ask the user to disambiguate via `package=<path>`.
+- **Zero matches with no config** → abort. Print what was searched and ask the user for `package=<path>`.
 
 ### Step 2 — Read metadata
 

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "com.elestrago.unity.package-tools",
-  "version": "2.5.2",
+  "version": "2.5.3",
   "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.5.2/README.md",
-  "changelogUrl": "https://gitlab.com/elestrago-pkg/package-tool/-/blob/2.5.2/CHANGELOG.md",
-  "licensesUrl": "https://gitlab.com/elestrago-pkg/package-tool/-/blob/2.5.2/LICENSE",
+  "documentationUrl": "https://gitlab.com/elestrago-pkg/package-tool/-/blob/2.5.3/README.md",
+  "changelogUrl": "https://gitlab.com/elestrago-pkg/package-tool/-/blob/2.5.3/CHANGELOG.md",
+  "licensesUrl": "https://gitlab.com/elestrago-pkg/package-tool/-/blob/2.5.3/LICENSE",
   "license": "MIT",
   "keywords": [
     "unity",