feat: Help older custom tools migrate to V3 automatically

Assets/Tests/Editor/OnionAssemblyDependencyTests.cs

@@ -851,6 +851,17 @@ public void SetupWizardStartup_WhenLoaded_SchedulesVersionCheckInsteadOfReadingS
             Assert.That(setupWizardSource, Does.Not.Contain("\n            TryShowOnVersionChange();"));
         }
 
+        [Test]
+        public void MigrationWizardStartup_WhenLoaded_SchedulesTargetCheckInsteadOfPreviewingSynchronously()
+        {
+            // Tests that migration target detection does not block the synchronous Editor startup hook.
+            string migrationWizardSource = ReadProductionSource(
+                "Packages/src/Editor/Presentation/Setup/ThirdPartyToolMigrationWizardWindow.cs");
+
+            Assert.That(migrationWizardSource, Does.Contain("EditorApplication.delayCall += TryShowOnMigrationTargets;"));
+            Assert.That(migrationWizardSource, Does.Not.Contain("\n            TryShowOnMigrationTargets();"));
+        }
+
         [Test]
         public void ProjectAsmdefs_WhenLoaded_DoNotReferenceRemovedSharedAssemblyGuid()
         {

Assets/Tests/Editor/SetupWizardWindowTests.cs

@@ -65,7 +65,10 @@ public void ShouldAutoShowForVersion_ReturnsExpectedValue(
             bool expected)
         {
             bool shouldAutoShow =
-                SetupWizardWindow.ShouldAutoShowForVersion(currentVersion, lastSeenVersion, suppressAutoShow);
+                SetupWizardWindow.ShouldAutoShowForVersion(
+                    currentVersion,
+                    lastSeenVersion,
+                    suppressAutoShow);
 
             Assert.That(shouldAutoShow, Is.EqualTo(expected));
         }

Assets/Tests/Editor/ThirdPartyToolMigrationWizardWindowTests.cs

@@ -0,0 +1,151 @@
+using NUnit.Framework;
+using UnityEditor;
+using UnityEngine;
+
+using io.github.hatayama.UnityCliLoop.Domain;
+using io.github.hatayama.UnityCliLoop.Presentation;
+
+namespace io.github.hatayama.UnityCliLoop.Tests.Editor
+{
+    /// <summary>
+    /// Test fixture that verifies the dedicated V3 custom tool migration wizard.
+    /// </summary>
+    public sealed class ThirdPartyToolMigrationWizardWindowTests
+    {
+        [TestCase(true, true)]
+        [TestCase(false, false)]
+        public void ShouldAutoShowForMigrationTargets_ReturnsDetectionResult(
+            bool hasMigrationTargets,
+            bool expected)
+        {
+            // Verifies that migration startup is controlled only by migration target detection.
+            bool shouldAutoShow =
+                ThirdPartyToolMigrationWizardWindow.ShouldAutoShowForMigrationTargets(hasMigrationTargets);
+
+            Assert.That(shouldAutoShow, Is.EqualTo(expected));
+        }
+
+        [TestCase(
+            1,
+            "1 file needs V3 custom tool migration.\n" +
+            "The Unity Console is showing errors because this file still uses the old custom tool API.\n\n" +
+            "Click Migrate to update it automatically. The errors should disappear after migration.")]
+        [TestCase(
+            3,
+            "3 files need V3 custom tool migration.\n" +
+            "The Unity Console is showing errors because these files still use the old custom tool API.\n\n" +
+            "Click Migrate to update them automatically. The errors should disappear after migration.")]
+        public void GetMigrationStatusText_WhenTargetsExist_ReturnsFileCount(
+            int fileCount,
+            string expectedText)
+        {
+            // Verifies that the migration wizard summarizes detected V2 custom tool files.
+            string text = ThirdPartyToolMigrationWizardWindow.GetMigrationStatusText(fileCount);
+
+            Assert.That(text, Is.EqualTo(expectedText));
+        }
+
+        [Test]
+        public void GetMigrationProgressText_WhenProgressExists_ReturnsCheckCount()
+        {
+            // Verifies that the migration wizard reports scan progress while migration targets are unknown.
+            ThirdPartyToolMigrationProgress progress = new(3, 12);
+
+            string text = ThirdPartyToolMigrationWizardWindow.GetMigrationProgressText(progress);
+
+            Assert.That(
+                text,
+                Is.EqualTo("Scanning project for V3 custom tool migration...\n3/12 checks complete."));
+        }
+
+        [TestCase(false, true, "Migrate")]
+        [TestCase(true, true, "Migrating...")]
+        [TestCase(false, false, "Nothing to migrate")]
+        public void GetMigrationButtonText_ReturnsExpectedLabel(
+            bool isMigrating,
+            bool hasMigrationTargets,
+            string expectedLabel)
+        {
+            // Verifies that the migration action communicates its current state.
+            string label = ThirdPartyToolMigrationWizardWindow.GetMigrationButtonText(
+                isMigrating,
+                hasMigrationTargets);
+
+            Assert.That(label, Is.EqualTo(expectedLabel));
+        }
+
+        [Test]
+        public void PrepareForOpen_PopulatesWindowStateBeforeShowing()
+        {
+            // Verifies that startup-created migration windows can preview immediately after CreateGUI.
+            ThirdPartyToolMigrationWizardWindow window =
+                ScriptableObject.CreateInstance<ThirdPartyToolMigrationWizardWindow>();
+            try
+            {
+                Rect position = new(12f, 34f, 360f, 220f);
+
+                ThirdPartyToolMigrationWizardWindow.PrepareForOpen(
+                    window,
+                    "Unity CLI Loop Migration",
+                    position,
+                    true);
+
+                SerializedObject serializedWindow = new(window);
+                SerializedProperty refreshProperty =
+                    serializedWindow.FindProperty("_shouldRefreshAfterCreateGui");
+
+                Assert.That(window.titleContent.text, Is.EqualTo("Unity CLI Loop Migration"));
+                Assert.That(window.position, Is.EqualTo(position));
+                Assert.That(window.minSize, Is.EqualTo(new Vector2(360f, 120f)));
+                Assert.That(refreshProperty, Is.Not.Null);
+                Assert.That(refreshProperty.boolValue, Is.True);
+            }
+            finally
+            {
+                Object.DestroyImmediate(window);
+            }
+        }
+
+        [Test]
+        public void WithContentHeight_UsesMeasuredHeightAndPreservesCenter()
+        {
+            // Verifies that the migration wizard resizes vertically from measured content height.
+            Rect initialRect = new(123f, 456f, 400f, 220f);
+            Vector2 frameSize = new(18f, 28f);
+
+            Rect resizedRect =
+                ThirdPartyToolMigrationWizardWindow.WithContentHeight(initialRect, 180f, frameSize);
+
+            Assert.That(resizedRect.center, Is.EqualTo(initialRect.center));
+            Assert.That(resizedRect.size, Is.EqualTo(new Vector2(360f, 208f)));
+        }
+
+        [Test]
+        public void WithContentHeight_WhenMeasuredHeightIsSmall_ClampsToMinimumHeight()
+        {
+            // Verifies that content fitting keeps the migration wizard from becoming unusably short.
+            Rect initialRect = new(123f, 456f, 400f, 220f);
+            Vector2 frameSize = new(18f, 28f);
+
+            Rect resizedRect =
+                ThirdPartyToolMigrationWizardWindow.WithContentHeight(initialRect, 12f, frameSize);
+
+            Assert.That(resizedRect.center, Is.EqualTo(initialRect.center));
+            Assert.That(resizedRect.size, Is.EqualTo(new Vector2(360f, 120f)));
+        }
+
+        [Test]
+        public void WithContentHeight_WhenCurrentWidthIsWide_UsesSetupWizardWidth()
+        {
+            // Verifies that content fitting keeps the migration wizard at Setup Wizard width.
+            Rect initialRect = new(123f, 456f, 520f, 220f);
+            Vector2 frameSize = new(18f, 28f);
+
+            Rect resizedRect =
+                ThirdPartyToolMigrationWizardWindow.WithContentHeight(initialRect, 120f, frameSize);
+
+            Assert.That(resizedRect.center, Is.EqualTo(initialRect.center));
+            Assert.That(resizedRect.size, Is.EqualTo(new Vector2(360f, 148f)));
+        }
+    }
+}

Packages/src/Editor/Application/UseCases/ThirdPartyToolMigrationUseCase.cs

@@ -0,0 +1,56 @@
+using System;
+using System.Diagnostics;
+using System.Threading;
+using System.Threading.Tasks;
+
+using io.github.hatayama.UnityCliLoop.Domain;
+
+namespace io.github.hatayama.UnityCliLoop.Application
+{
+    /// <summary>
+    /// Coordinates V3 migration for third-party custom tools without owning file-system details.
+    /// </summary>
+    public sealed class ThirdPartyToolMigrationUseCase
+    {
+        private readonly IThirdPartyToolMigrationPort _migrationPort;
+
+        public ThirdPartyToolMigrationUseCase(IThirdPartyToolMigrationPort migrationPort)
+        {
+            Debug.Assert(migrationPort != null, "migrationPort must not be null");
+
+            _migrationPort = migrationPort ?? throw new ArgumentNullException(nameof(migrationPort));
+        }
+
+        public ThirdPartyToolMigrationPreview PreviewMigration(string projectRoot)
+        {
+            Debug.Assert(!string.IsNullOrEmpty(projectRoot), "projectRoot must not be null or empty");
+
+            return _migrationPort.PreviewMigration(projectRoot);
+        }
+
+        public Task<ThirdPartyToolMigrationPreview> PreviewMigrationAsync(
+            string projectRoot,
+            IProgress<ThirdPartyToolMigrationProgress> progress,
+            CancellationToken ct)
+        {
+            Debug.Assert(!string.IsNullOrEmpty(projectRoot), "projectRoot must not be null or empty");
+            Debug.Assert(progress != null, "progress must not be null");
+
+            return _migrationPort.PreviewMigrationAsync(projectRoot, progress, ct);
+        }
+
+        public Task<bool> HasMigrationTargetsAsync(string projectRoot, CancellationToken ct)
+        {
+            Debug.Assert(!string.IsNullOrEmpty(projectRoot), "projectRoot must not be null or empty");
+
+            return _migrationPort.HasMigrationTargetsAsync(projectRoot, ct);
+        }
+
+        public ThirdPartyToolMigrationResult ApplyMigration(string projectRoot)
+        {
+            Debug.Assert(!string.IsNullOrEmpty(projectRoot), "projectRoot must not be null or empty");
+
+            return _migrationPort.ApplyMigration(projectRoot);
+        }
+    }
+}

Packages/src/Editor/Application/UseCases/ThirdPartyToolMigrationUseCaseRegistry.cs

@@ -0,0 +1,30 @@
+using System;
+using System.Diagnostics;
+
+namespace io.github.hatayama.UnityCliLoop.Application
+{
+    /// <summary>
+    /// Stores the third-party tool migration use case for Unity-created presentation objects.
+    /// </summary>
+    internal static class ThirdPartyToolMigrationUseCaseRegistry
+    {
+        private static ThirdPartyToolMigrationUseCase RegisteredUseCase;
+
+        internal static void Register(ThirdPartyToolMigrationUseCase useCase)
+        {
+            Debug.Assert(useCase != null, "useCase must not be null");
+
+            RegisteredUseCase = useCase ?? throw new ArgumentNullException(nameof(useCase));
+        }
+
+        internal static ThirdPartyToolMigrationUseCase GetRegisteredUseCase()
+        {
+            if (RegisteredUseCase == null)
+            {
+                throw new InvalidOperationException("Unity CLI Loop third-party tool migration use case is not registered.");
+            }
+
+            return RegisteredUseCase;
+        }
+    }
+}

Packages/src/Editor/CompositionRoot/UnityCliLoopApplicationRegistration.cs

@@ -32,6 +32,8 @@ internal UnityCliLoopApplicationServices Register()
                 toolRegistrarService));
             SkillSetupUseCase skillSetupUseCase = new(new SkillSetupService(new ToolSkillSetupService(toolSettingsService)));
             SkillSetupUseCaseRegistry.Register(skillSetupUseCase);
+            ThirdPartyToolMigrationUseCaseRegistry.Register(
+                new ThirdPartyToolMigrationUseCase(new ThirdPartyToolMigrationFileService()));
             CliSetupApplicationFacade.RegisterService(new CliSetupApplicationService(
                 new CliInstallationDetector(),
                 new NativeCliInstallerService()));