@atelierai/uco 1.0.0

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/UI/Window/MainWindowInitializer.cs

@@ -0,0 +1,47 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
+│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
+│  Copyright (c) 2025 Ivan Murzak                                  │
+│  Licensed under the Apache License, Version 2.0.                 │
+│  See the LICENSE file in the project root for more information.  │
+└──────────────────────────────────────────────────────────────────┘
+*/
+
+#nullable enable
+using com.AtelierAI.Unity.Copilot.Editor.Utils;
+using UnityEditor;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.UI
+{
+    [InitializeOnLoad]
+    static class MainWindowInitializer
+    {
+        static PlayerPrefsBool isInitialized = new PlayerPrefsBool("Unity-MCP.MainWindow.Initialized");
+
+        static MainWindowInitializer()
+        {
+            if (!UnityProcessGuard.ShouldInitialize(AssetDatabase.IsAssetImportWorkerProcess()))
+                return;
+
+            if (isInitialized.Value)
+                return;
+
+            EditorApplication.update += PerformInitialization;
+        }
+
+        static void PerformInitialization()
+        {
+            EditorApplication.update -= PerformInitialization;
+
+            if (isInitialized.Value)
+                return;
+
+            // Perform initialization
+            UnityCopilotPluginEditor.InitSingletonIfNeeded();
+            MainWindowEditor.ShowWindow();
+
+            isInitialized.Value = true;
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/UI/Window/MainWindowInitializer.cs.meta

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

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/UI/Window/NotificationPopupWindow.cs

@@ -0,0 +1,114 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
+│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
+│  Copyright (c) 2025 Ivan Murzak                                  │
+│  Licensed under the Apache License, Version 2.0.                 │
+│  See the LICENSE file in the project root for more information.  │
+└──────────────────────────────────────────────────────────────────┘
+*/
+
+#nullable enable
+
+using System;
+using com.AtelierAI.Unity.Copilot.Editor.Utils;
+using UnityEditor;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.UI
+{
+    /// <summary>
+    /// A non-blocking popup window for displaying notification messages.
+    /// Uses ShowUtility() so it floats above the editor without blocking interaction.
+    /// Serves as a base class for popup windows with customizable UXML/USS and UI binding.
+    /// </summary>
+    public class NotificationPopupWindow : CopilotWindowBase
+    {
+        static readonly string[] _windowUxmlPaths = EditorAssetLoader.GetEditorAssetPaths("Editor/UI/uxml/NotificationPopupWindow.uxml");
+        static readonly string[] _windowUssPaths = EditorAssetLoader.GetEditorAssetPaths("Editor/UI/uss/NotificationPopupWindow.uss");
+
+        protected override string[] WindowUxmlPaths => _windowUxmlPaths;
+        protected override string[] WindowUssPaths => _windowUssPaths;
+        protected override string WindowTitle => internalTitle;
+
+        public const float DefaultWidth = 350;
+        public const float DefaultHeight = 200;
+        public const float DefaultMinWidth = 350;
+        public const float DefaultMinHeight = 100;
+        public const float DefaultMaxWidth = 350;
+        public const float DefaultMaxHeight = 300;
+
+        private string internalTitle = string.Empty;
+        private string internalMessage = string.Empty;
+
+        protected static void CenterAndSizeWindow(
+            EditorWindow window,
+            float width,
+            float height,
+            float minWidth,
+            float minHeight,
+            float maxWidth,
+            float maxHeight)
+        {
+            var mainWindowRect = EditorGUIUtility.GetMainWindowPosition();
+            var x = mainWindowRect.x + (mainWindowRect.width - width) / 2f;
+            var y = mainWindowRect.y + (mainWindowRect.height - height) / 2f;
+
+            window.minSize = new Vector2(minWidth, minHeight);
+            window.maxSize = new Vector2(maxWidth, maxHeight);
+            window.position = new Rect(x, y, width, height);
+        }
+
+        public static void Show(
+            string windowTitle,
+            string title,
+            string message,
+            float width = DefaultWidth,
+            float height = DefaultHeight,
+            float minWidth = DefaultMinWidth,
+            float minHeight = DefaultMinHeight,
+            float maxWidth = DefaultMaxWidth,
+            float maxHeight = DefaultMaxHeight)
+        {
+            var window = GetWindow<NotificationPopupWindow>(utility: false, title: windowTitle, focus: true); // CreateInstance<NotificationPopupWindow>();
+            window.internalTitle = title;
+            window.internalMessage = message;
+            window.titleContent = new GUIContent(windowTitle);
+            window.SetupWindowWithIcon(windowTitle);
+
+            CenterAndSizeWindow(window, width, height, minWidth, minHeight, maxWidth, maxHeight);
+
+            window.CreateGUI();
+            window.ShowUtility();
+        }
+
+        public override void CreateGUI()
+        {
+            rootVisualElement.Clear();
+            ApplyStyleSheets(rootVisualElement);
+
+            var visualTree = EditorAssetLoader.LoadAssetAtPath<VisualTreeAsset>(WindowUxmlPaths);
+            if (visualTree == null)
+                throw new InvalidOperationException("UXML template not found in specified paths");
+
+            visualTree.CloneTree(rootVisualElement);
+            BindUI(rootVisualElement);
+        }
+
+        protected virtual void BindUI(VisualElement root)
+        {
+            var titleLabel = root.Q<Label>("title");
+            if (titleLabel != null)
+                titleLabel.text = internalTitle;
+
+            var messageLabel = root.Q<Label>("message");
+            if (messageLabel != null)
+                messageLabel.text = internalMessage;
+
+            var okButton = root.Q<Button>("btn-ok");
+            if (okButton != null)
+                okButton.clicked += Close;
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/UI/Window/NotificationPopupWindow.cs.meta

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

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/UI/Window/SerializationCheckWindow.cs

@@ -0,0 +1,190 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
+│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
+│  Copyright (c) 2025 Ivan Murzak                                  │
+│  Licensed under the Apache License, Version 2.0.                 │
+│  See the LICENSE file in the project root for more information.  │
+└──────────────────────────────────────────────────────────────────┘
+*/
+
+#nullable enable
+
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using com.AtelierAI.Uco.Framework.Common.Utils;
+using com.IvanMurzak.ReflectorNet;
+using com.AtelierAI.Unity.Copilot.Editor.Utils;
+using com.AtelierAI.Unity.Copilot.Utils;
+using Microsoft.Extensions.Logging;
+using UnityEditor;
+using UnityEditor.UIElements;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.UI
+{
+    /// <summary>
+    /// An editor window for testing object serialization using the MCP reflector.
+    /// </summary>
+    public class SerializationCheckWindow : CopilotWindowBase
+    {
+        private static readonly string[] _windowUxmlPaths = EditorAssetLoader.GetEditorAssetPaths("Editor/UI/uxml/SerializationCheckWindow.uxml");
+        private static readonly string[] _windowUssPaths = EditorAssetLoader.GetEditorAssetPaths("Editor/UI/uss/SerializationCheckWindow.uss");
+
+        protected override string[] WindowUxmlPaths => _windowUxmlPaths;
+        protected override string[] WindowUssPaths => _windowUssPaths;
+        protected override string WindowTitle => "Serialization Check";
+
+        private ObjectField? targetField;
+        private Toggle? recursiveToggle;
+        private Button? serializeButton;
+        private Button? copyButton;
+        private Label? outputHeader;
+        private ListView? outputList;
+        private readonly List<string> outputLines = new();
+        private string fullOutputText = string.Empty;
+
+        public static void ShowWindow()
+        {
+            var window = GetWindow<SerializationCheckWindow>(utility: false, "Serialization Check", focus: true);
+            window.SetupWindowWithIcon();
+            window.minSize = new Vector2(400, 500);
+            window.Show();
+        }
+
+        protected override void OnGUICreated(VisualElement root)
+        {
+            BindUI(root);
+        }
+
+        private void BindUI(VisualElement root)
+        {
+            // Bind target object field
+            targetField = root.Q<ObjectField>("target-field");
+            if (targetField == null)
+                throw new InvalidOperationException("target-field ObjectField not found in UXML");
+            targetField.objectType = typeof(UnityEngine.Object);
+
+            // Bind recursive toggle
+            recursiveToggle = root.Q<Toggle>("recursive-toggle");
+            if (recursiveToggle == null)
+                throw new InvalidOperationException("recursive-toggle Toggle not found in UXML");
+
+            // Bind serialize button
+            serializeButton = root.Q<Button>("btn-serialize");
+            if (serializeButton == null)
+                throw new InvalidOperationException("btn-serialize Button not found in UXML");
+            serializeButton.clicked += OnSerializeClicked;
+
+            // Bind copy button
+            copyButton = root.Q<Button>("btn-copy");
+            if (copyButton == null)
+                throw new InvalidOperationException("btn-copy Button not found in UXML");
+            copyButton.clicked += OnCopyClicked;
+
+            // Bind output header
+            outputHeader = root.Q<Label>("output-header");
+            if (outputHeader == null)
+                throw new InvalidOperationException("output-header Label not found in UXML");
+
+            // Bind output list
+            outputList = root.Q<ListView>("output-list");
+            if (outputList == null)
+                throw new InvalidOperationException("output-list ListView not found in UXML");
+
+            outputList.itemsSource = outputLines;
+            outputList.virtualizationMethod = CollectionVirtualizationMethod.DynamicHeight;
+            outputList.makeItem = () =>
+            {
+                var label = new Label();
+                label.AddToClassList("json-text-line");
+                return label;
+            };
+            outputList.bindItem = (element, index) =>
+            {
+                if (element is Label label && index < outputLines.Count)
+                    label.text = outputLines[index];
+            };
+            outputList.selectionType = SelectionType.None;
+        }
+
+        private void OnSerializeClicked()
+        {
+            if (targetField == null || recursiveToggle == null || outputList == null || outputHeader == null)
+                return;
+
+            var target = targetField.value;
+            var recursive = recursiveToggle.value;
+
+            try
+            {
+                var logger = UnityLoggerFactory.LoggerFactory.CreateLogger(nameof(SerializationCheckWindow));
+                var reflector = UnityCopilotPluginEditor.Instance.Reflector ?? throw new InvalidOperationException("Reflector is null");
+
+                logger.LogInformation($"Serializing target '{target?.name}' of type '{target?.GetType().GetTypeId()}' with recursive={recursive}");
+
+                var stopwatch = Stopwatch.StartNew();
+
+                var serialized = reflector.Serialize(
+                    obj: target,
+                    fallbackType: null,
+                    name: target?.name,
+                    recursive: recursive,
+                    context: null,
+                    logger: logger);
+
+                var json = serialized.ToPrettyJson();
+
+                stopwatch.Stop();
+
+                logger.LogInformation(json);
+
+                outputHeader.text = $"Output ({stopwatch.ElapsedMilliseconds}ms)";
+                SetOutput(json);
+            }
+            catch (Exception ex)
+            {
+                outputHeader.text = "Output";
+                SetOutput($"Error: {ex.Message}\n\n{ex.StackTrace}");
+                Logger.LogError(ex, "Failed to serialize target");
+            }
+        }
+
+        private void SetOutput(string text)
+        {
+            fullOutputText = text;
+            outputLines.Clear();
+            outputLines.AddRange(text.Split('\n'));
+            outputList?.RefreshItems();
+        }
+
+        private void OnCopyClicked()
+        {
+            EditorGUIUtility.systemCopyBuffer = fullOutputText;
+
+            if (copyButton != null)
+            {
+                var originalText = copyButton.text;
+                copyButton.text = "Copied!";
+
+                copyButton.schedule.Execute(() =>
+                {
+                    if (copyButton != null)
+                    {
+                        copyButton.text = originalText;
+                    }
+                }).ExecuteLater(1500);
+            }
+        }
+
+        private void OnDestroy()
+        {
+            if (serializeButton != null)
+                serializeButton.clicked -= OnSerializeClicked;
+            if (copyButton != null)
+                copyButton.clicked -= OnCopyClicked;
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/UI/Window/SerializationCheckWindow.cs.meta

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

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/UI/Window/UpdatePopupWindow.cs

@@ -0,0 +1,252 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  Author: Ivan Murzak (https://github.com/IvanMurzak)             │
+│  Repository: GitHub (https://github.com/IvanMurzak/Unity-MCP)    │
+│  Copyright (c) 2025 Ivan Murzak                                  │
+│  Licensed under the Apache License, Version 2.0.                 │
+│  See the LICENSE file in the project root for more information.  │
+└──────────────────────────────────────────────────────────────────┘
+*/
+
+#nullable enable
+
+using System;
+using com.AtelierAI.Unity.Copilot.Editor.DependencyResolver;
+using com.AtelierAI.Unity.Copilot.Editor.Utils;
+using R3;
+using UnityEditor;
+using UnityEditor.PackageManager;
+using UnityEditor.PackageManager.Requests;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.UI
+{
+    /// <summary>
+    /// A popup window that notifies the user when a new version of Unity Co-Pilot is available.
+    /// </summary>
+    public class UpdatePopupWindow : NotificationPopupWindow
+    {
+        private static readonly string[] _windowUxmlPaths = EditorAssetLoader.GetEditorAssetPaths("Editor/UI/uxml/UpdatePopupWindow.uxml");
+        private static readonly string[] _windowUssPaths = EditorAssetLoader.GetEditorAssetPaths("Editor/UI/uss/UpdatePopupWindow.uss");
+        private static readonly string[] LogoIconPaths = EditorAssetLoader.GetEditorAssetPaths("Editor/Gizmos/logo_512.png");
+
+        private const string PackageId = "com.atelierai.unity.copilot";
+
+        protected override string[] WindowUxmlPaths => _windowUxmlPaths;
+        protected override string[] WindowUssPaths => _windowUssPaths;
+        protected override string WindowTitle => "Update Available";
+
+        // [SerializeField] so the version strings survive Unity's domain reload (script
+        // recompile). Without this, after a recompile the EditorWindow instance is recreated,
+        // CreateGUI() is invoked again, and BindUI() re-binds button click handlers — but
+        // these private fields revert to empty, so the labels render empty and "Install
+        // Update" attempts to install "{PackageId}@" (empty version), which silently fails.
+        // See https://github.com/IvanMurzak/uco-plugin/issues/702.
+        [SerializeField] private string currentVersion = string.Empty;
+        [SerializeField] private string latestVersion = string.Empty;
+
+        // The AddRequest holds a native Package Manager handle and the R3 subscription holds
+        // a reactive pipeline; neither survives a domain reload. Unity does, however, carry
+        // these private references over the reload boundary even without [SerializeField], so
+        // OnInstallUpdateClicked's "already in progress" guard would permanently lock the
+        // button. ResetInstallState() (called from OnEnable + OnDestroy) keeps the contract.
+        private AddRequest? addRequest;
+        private IDisposable? _stopSubscription;
+
+        /// <summary>
+        /// Shows the update popup window with version information.
+        /// </summary>
+        public static UpdatePopupWindow ShowWindow(string currentVersion, string latestVersion)
+        {
+            var window = GetWindow<UpdatePopupWindow>(utility: false, "Update Available", focus: true);
+            window.currentVersion = currentVersion ?? "Unknown";
+            window.latestVersion = latestVersion ?? "Unknown";
+
+            CenterAndSizeWindow(
+                window: window,
+                width: 350f,
+                height: 450f,
+                minWidth: 350f,
+                minHeight: 450f,
+                maxWidth: 350f,
+                maxHeight: 450f);
+
+            window.CreateGUI();
+            window.Show();
+            window.Focus();
+
+            return window;
+        }
+
+        protected override void OnEnable()
+        {
+            base.OnEnable();
+            ResetInstallState();
+        }
+
+        protected override void BindUI(VisualElement root)
+        {
+            // Set icon
+            var iconContainer = root.Q<VisualElement>("icon-container");
+            if (iconContainer == null)
+                throw new InvalidOperationException("icon-container VisualElement not found in UXML");
+
+            var icon = EditorAssetLoader.LoadAssetAtPath<Texture2D>(LogoIconPaths);
+            if (icon == null)
+                throw new InvalidOperationException("Logo icon not found in specified paths");
+
+            iconContainer.style.backgroundImage = new StyleBackground(icon);
+
+            // Set version labels
+            var currentVersionLabel = root.Q<Label>("current-version-value");
+            if (currentVersionLabel == null)
+                throw new InvalidOperationException("current-version-value Label not found in UXML");
+            currentVersionLabel.text = currentVersion;
+
+            var latestVersionLabel = root.Q<Label>("latest-version-value");
+            if (latestVersionLabel == null)
+                throw new InvalidOperationException("latest-version-value Label not found in UXML");
+            latestVersionLabel.text = latestVersion;
+
+            // Bind buttons
+            var installUpdateButton = root.Q<Button>("btn-install-update");
+            if (installUpdateButton == null)
+                throw new InvalidOperationException("btn-install-update Button not found in UXML");
+            installUpdateButton.clicked += OnInstallUpdateClicked;
+
+            var viewReleasesButton = root.Q<Button>("btn-view-releases");
+            if (viewReleasesButton == null)
+                throw new InvalidOperationException("btn-view-releases Button not found in UXML");
+            viewReleasesButton.clicked += OnViewReleasesClicked;
+
+            var skipVersionButton = root.Q<Button>("btn-skip-version");
+            if (skipVersionButton == null)
+                throw new InvalidOperationException("btn-skip-version Button not found in UXML");
+            skipVersionButton.clicked += OnSkipVersionClicked;
+
+            var doNotShowAgainButton = root.Q<Button>("btn-do-not-show-again");
+            if (doNotShowAgainButton == null)
+                throw new InvalidOperationException("btn-do-not-show-again Button not found in UXML");
+            doNotShowAgainButton.clicked += OnDoNotShowAgainClicked;
+        }
+
+        private void OnInstallUpdateClicked()
+        {
+            if (addRequest != null || _stopSubscription != null)
+                return; // Already in progress
+
+            var installButton = rootVisualElement.Q<Button>("btn-install-update");
+            if (installButton == null)
+                throw new InvalidOperationException("btn-install-update Button not found in UXML");
+
+            installButton.SetEnabled(false);
+
+            var currentStatus = CopilotServerManager.ServerStatus.CurrentValue;
+            if (currentStatus == CopilotServerStatus.Running || currentStatus == CopilotServerStatus.Starting ||
+                currentStatus == CopilotServerStatus.Stopping)
+            {
+                installButton.text = "Stopping server...";
+                if (currentStatus != CopilotServerStatus.Stopping)
+                    CopilotServerManager.StopServer();
+                _stopSubscription = CopilotServerManager.ServerStatus
+                    .Where(status => status == CopilotServerStatus.Stopped)
+                    .Take(1)
+                    .ObserveOnCurrentSynchronizationContext()
+                    .Subscribe(_ => StartPackageInstall());
+            }
+            else
+            {
+                StartPackageInstall();
+            }
+        }
+
+        private void StartPackageInstall()
+        {
+            _stopSubscription?.Dispose();
+            _stopSubscription = null;
+
+            var installButton = rootVisualElement.Q<Button>("btn-install-update");
+            if (installButton != null)
+                installButton.text = "Installing...";
+
+            // Force a clean post-install recompile so an unrelated user-asmdef
+            // error can't leave the OLD plugin AppDomain loaded with the new
+            // package files on disk.
+            RecompileGate.Reset();
+
+            addRequest = Client.Add($"{PackageId}@{latestVersion}");
+            EditorApplication.update += OnPackageInstallProgress;
+        }
+
+        private void OnPackageInstallProgress()
+        {
+            if (addRequest == null)
+            {
+                EditorApplication.update -= OnPackageInstallProgress;
+                return;
+            }
+
+            if (!addRequest.IsCompleted)
+                return; // wait until completed
+
+            EditorApplication.update -= OnPackageInstallProgress;
+
+            if (addRequest.Status == StatusCode.Success)
+            {
+                UnityCopilotPluginEditor.Instance.LogInfo("Package updated to version {version}", typeof(UpdatePopupWindow), latestVersion);
+                EditorUtility.DisplayDialog(
+                    "Update Complete",
+                    $"Unity Co-Pilot has been updated to version {latestVersion}.\n\nUnity will recompile scripts automatically.",
+                    "OK");
+            }
+            else if (addRequest.Status >= StatusCode.Failure)
+            {
+                var errorMessage = addRequest.Error?.message ?? "Unknown error";
+                UnityCopilotPluginEditor.Instance.LogError("Failed to update package: {error}", typeof(UpdatePopupWindow), errorMessage);
+                EditorUtility.DisplayDialog(
+                    "Update Failed",
+                    $"Failed to update the package:\n{errorMessage}",
+                    "OK");
+
+                // Re-enable the button on failure
+                var installButton = rootVisualElement.Q<Button>("btn-install-update");
+                if (installButton != null)
+                {
+                    installButton.SetEnabled(true);
+                    installButton.text = "Install Update";
+                }
+            }
+
+            addRequest = null;
+            Close();
+        }
+
+        private void OnViewReleasesClicked()
+        {
+            Application.OpenURL(UpdateChecker.ReleasesUrl);
+        }
+
+        private void OnSkipVersionClicked()
+        {
+            UpdateChecker.SkipVersion(latestVersion);
+            Close();
+        }
+
+        private void OnDoNotShowAgainClicked()
+        {
+            UpdateChecker.IsDoNotShowAgain = true;
+            Close();
+        }
+
+        void OnDestroy() => ResetInstallState();
+
+        private void ResetInstallState()
+        {
+            EditorApplication.update -= OnPackageInstallProgress;
+            _stopSubscription?.Dispose();
+            _stopSubscription = null;
+            addRequest = null;
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/UI/Window/UpdatePopupWindow.cs.meta

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

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/UI/Window.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 6c8dc3700c6654b4bb6c48de38aec1e7
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/UI.meta

@@ -0,0 +1,8 @@
+fileFormatVersion: 2
+guid: 858199e87db7f344199755afe32efc38
+folderAsset: yes
+DefaultImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: