@atelierai/uco 1.0.0

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/UI/Components/ExtensionPanel.cs

@@ -0,0 +1,379 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  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.IO;
+using System.Linq;
+using System.Net.Http;
+using System.Text;
+using System.Text.Json;
+using System.Text.Json.Nodes;
+using System.Text.Json.Serialization.Metadata;
+using System.Threading.Tasks;
+using com.AtelierAI.Unity.Copilot.Editor.Utils;
+using UnityEditor;
+using UnityEditor.PackageManager;
+using UnityEngine;
+using UnityEngine.UIElements;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.UI
+{
+    /// <summary>
+    /// Reusable extension item component backed by the ExtensionItem.uxml template.
+    /// Displays an extension name, description, and install/update button with progress tracking.
+    /// Installs packages via OpenUPM scoped registry in manifest.json.
+    /// </summary>
+    public class ExtensionPanel
+    {
+        private static readonly string[] TemplatePaths = EditorAssetLoader.GetEditorAssetPaths("Editor/UI/uxml/ExtensionItem.uxml");
+
+        private const string RegistryName = "package.openupm.com";
+        private const string RegistryUrl = "https://package.openupm.com";
+        private static readonly string[] RequiredScopes =
+        {
+            "com.ivanmurzak",
+            "extensions.unity",
+            "org.nuget.com.ivanmurzak",
+            "org.nuget.microsoft",
+            "org.nuget.system",
+            "org.nuget.r3"
+        };
+
+        private readonly Label _name;
+        private readonly Label _description;
+        private readonly Button _actionBtn;
+        private readonly ExtensionData _data;
+
+        /// <summary>
+        /// The root visual element of the extension panel. Add this to a parent container.
+        /// </summary>
+        public VisualElement Root { get; }
+
+        /// <summary>
+        /// Creates a new extension panel from the UXML template.
+        /// Button is hidden until <see cref="RefreshStatus"/> determines the correct state.
+        /// </summary>
+        /// <param name="data">The extension data including name, description, package ID, and tools list.</param>
+        public ExtensionPanel(ExtensionData data)
+        {
+            _data = data;
+
+            var template = EditorAssetLoader.LoadAssetAtPath<VisualTreeAsset>(TemplatePaths)
+                ?? throw new NullReferenceException($"Failed to load ExtensionItem.uxml. Checked: {string.Join(", ", TemplatePaths)}");
+
+            var tree = template.CloneTree();
+            Root = tree.Q<VisualElement>("extension-item")
+                ?? throw new NullReferenceException("VisualElement 'extension-item' not found in ExtensionItem.uxml.");
+
+            _name = Root.Q<Label>("extension-name")
+                ?? throw new NullReferenceException("Label 'extension-name' not found in ExtensionItem.uxml.");
+            _description = Root.Q<Label>("extension-desc")
+                ?? throw new NullReferenceException("Label 'extension-desc' not found in ExtensionItem.uxml.");
+            _actionBtn = Root.Q<Button>("extension-install-btn")
+                ?? throw new NullReferenceException("Button 'extension-install-btn' not found in ExtensionItem.uxml.");
+
+            _name.text = data.Name;
+            _description.text = data.Description;
+
+            Root.tooltip = BuildTooltip(data);
+
+            ShowAsChecking();
+        }
+
+        /// <summary>
+        /// Determines the button state based on whether the package is installed
+        /// and whether a newer version is available on OpenUPM.
+        /// </summary>
+        /// <param name="installedVersion">
+        /// The currently installed version of this package, or null if not installed.
+        /// </param>
+        public void RefreshStatus(string? installedVersion)
+        {
+            _actionBtn.UnregisterCallback<ClickEvent>(OnActionClicked);
+
+            if (installedVersion == null)
+            {
+                ShowAsInstall();
+                return;
+            }
+
+            ShowAsChecking();
+            _ = CheckForUpdateAsync(installedVersion);
+        }
+
+        private void ShowAsChecking()
+        {
+            _actionBtn.text = "Checking...";
+            _actionBtn.tooltip = $"Checking status of {_data.Name} extension...";
+            _actionBtn.RemoveFromClassList("btn-primary");
+            _actionBtn.AddToClassList("btn-secondary");
+            _actionBtn.style.display = DisplayStyle.Flex;
+            _actionBtn.SetEnabled(false);
+        }
+
+        private void ShowAsInstall()
+        {
+            _actionBtn.text = "Install";
+            _actionBtn.tooltip = $"Install {_data.Name} extension via OpenUPM.\nPackage: {_data.PackageId}";
+            _actionBtn.RemoveFromClassList("btn-primary");
+            _actionBtn.AddToClassList("btn-secondary");
+            _actionBtn.style.display = DisplayStyle.Flex;
+            _actionBtn.SetEnabled(true);
+
+            _actionBtn.RegisterCallback<ClickEvent>(OnActionClicked);
+        }
+
+        private void ShowAsUpdate(string installedVersion, string latestVersion)
+        {
+            _actionBtn.text = "Update";
+            _actionBtn.tooltip = $"Update {_data.Name} extension from {installedVersion} to {latestVersion}.\nPackage: {_data.PackageId}";
+            _actionBtn.RemoveFromClassList("btn-secondary");
+            _actionBtn.AddToClassList("btn-primary");
+            _actionBtn.style.display = DisplayStyle.Flex;
+            _actionBtn.SetEnabled(true);
+
+            _actionBtn.RegisterCallback<ClickEvent>(OnActionClicked);
+        }
+
+        private async void OnActionClicked(ClickEvent evt)
+        {
+            _actionBtn.UnregisterCallback<ClickEvent>(OnActionClicked);
+            await InstallOrUpdateAsync();
+        }
+
+        private async Task CheckForUpdateAsync(string installedVersion)
+        {
+            try
+            {
+                var latestVersion = await FetchLatestOpenUpmVersionAsync(_data.PackageId);
+                if (latestVersion != null && UpdateChecker.IsNewerVersion(latestVersion, installedVersion))
+                {
+                    EditorApplication.delayCall += () => ShowAsUpdate(installedVersion, latestVersion);
+                    return;
+                }
+            }
+            catch
+            {
+                // Network failure is non-critical
+            }
+
+            EditorApplication.delayCall += () => ShowAsInstalled();
+        }
+
+        private void ShowAsInstalled()
+        {
+            _actionBtn.text = "Installed";
+            _actionBtn.tooltip = $"{_data.Name} extension is installed and up to date.";
+            _actionBtn.RemoveFromClassList("btn-primary");
+            _actionBtn.AddToClassList("btn-secondary");
+            _actionBtn.style.display = DisplayStyle.Flex;
+            _actionBtn.SetEnabled(false);
+        }
+
+        private async Task InstallOrUpdateAsync()
+        {
+            var isUpdate = _actionBtn.text == "Update";
+            _actionBtn.SetEnabled(false);
+            _actionBtn.text = isUpdate ? "Updating..." : "Installing...";
+
+            try
+            {
+                var version = await FetchLatestOpenUpmVersionAsync(_data.PackageId);
+                if (version == null)
+                {
+                    Debug.LogError($"[Unity Copilot] Failed to fetch latest version for '{_data.Name}' from OpenUPM.");
+                    ResetButton(isUpdate);
+                    return;
+                }
+
+                var manifestPath = Path.Combine(Application.dataPath, "../Packages/manifest.json");
+                if (!AddToManifest(manifestPath, _data.PackageId, version))
+                {
+                    ResetButton(isUpdate);
+                    return;
+                }
+
+                Debug.Log($"[Unity Copilot] Extension '{_data.Name}' ({_data.PackageId}@{version}) added to manifest.json. Resolving packages...");
+                Client.Resolve();
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"[Unity Copilot] Failed to {(isUpdate ? "update" : "install")} extension '{_data.Name}': {ex.Message}");
+                ResetButton(isUpdate);
+            }
+        }
+
+        private void ResetButton(bool isUpdate)
+        {
+            _actionBtn.SetEnabled(true);
+            _actionBtn.text = isUpdate ? "Update" : "Install";
+            _actionBtn.RegisterCallback<ClickEvent>(OnActionClicked);
+        }
+
+        /// <summary>
+        /// Adds the OpenUPM scoped registry (if needed) and the package dependency to manifest.json.
+        /// </summary>
+        internal static bool AddToManifest(string manifestPath, string packageId, string version)
+        {
+            if (!File.Exists(manifestPath))
+            {
+                Debug.LogError($"[Unity Copilot] {manifestPath} not found.");
+                return false;
+            }
+
+            var jsonText = File.ReadAllText(manifestPath);
+            var manifest = JsonNode.Parse(jsonText)?.AsObject();
+            if (manifest == null)
+            {
+                Debug.LogError($"[Unity Copilot] Failed to parse {manifestPath} as JSON.");
+                return false;
+            }
+
+            EnsureScopedRegistry(manifest);
+
+            var dependencies = manifest["dependencies"]?.AsObject();
+            if (dependencies == null)
+            {
+                dependencies = new JsonObject();
+                manifest["dependencies"] = dependencies;
+            }
+            dependencies[packageId] = version;
+
+            var options = new JsonSerializerOptions
+            {
+                WriteIndented = true,
+                TypeInfoResolver = new DefaultJsonTypeInfoResolver()
+            };
+            File.WriteAllText(manifestPath, manifest.ToJsonString(options));
+            return true;
+        }
+
+        private static void EnsureScopedRegistry(JsonObject manifest)
+        {
+            var registries = manifest["scopedRegistries"]?.AsArray();
+            if (registries == null)
+            {
+                registries = new JsonArray();
+                manifest["scopedRegistries"] = registries;
+            }
+
+            JsonObject? openUpmEntry = null;
+            foreach (var entry in registries)
+            {
+                if (entry?.AsObject() is JsonObject obj
+                    && obj["name"]?.GetValue<string>() == RegistryName)
+                {
+                    openUpmEntry = obj;
+                    break;
+                }
+            }
+
+            if (openUpmEntry == null)
+            {
+                openUpmEntry = new JsonObject
+                {
+                    ["name"] = RegistryName,
+                    ["url"] = RegistryUrl,
+                    ["scopes"] = new JsonArray()
+                };
+                registries.Add(openUpmEntry);
+            }
+
+            var scopes = openUpmEntry["scopes"]?.AsArray();
+            if (scopes == null)
+            {
+                scopes = new JsonArray();
+                openUpmEntry["scopes"] = scopes;
+            }
+
+            var existingScopes = scopes
+                .Select(s => s?.GetValue<string>())
+                .Where(s => s != null)
+                .ToHashSet();
+
+            foreach (var scope in RequiredScopes)
+            {
+                if (!existingScopes.Contains(scope))
+                    scopes.Add(scope);
+            }
+        }
+
+        /// <summary>
+        /// Fetches the latest version of a package from the OpenUPM registry.
+        /// </summary>
+        private static async Task<string?> FetchLatestOpenUpmVersionAsync(string packageId)
+        {
+            using var client = new HttpClient();
+            client.DefaultRequestHeaders.Add("User-Agent", "Unity-Copilot-ExtensionPanel");
+            client.Timeout = TimeSpan.FromSeconds(10);
+
+            var json = await client.GetStringAsync($"{RegistryUrl}/{packageId}");
+            using var doc = JsonDocument.Parse(json);
+
+            if (!doc.RootElement.TryGetProperty("dist-tags", out var distTags))
+                return null;
+
+            if (!distTags.TryGetProperty("latest", out var latest))
+                return null;
+
+            return latest.GetString();
+        }
+
+        private static string BuildTooltip(ExtensionData data)
+        {
+            var sb = new StringBuilder();
+            sb.Append(data.Description);
+            sb.AppendLine();
+
+            if (data.Tools.Length > 0)
+            {
+                sb.AppendLine();
+                sb.AppendLine("Tools:");
+
+                var maxNameLen = 0;
+                foreach (var (toolName, _) in data.Tools)
+                {
+                    if (toolName.Length > maxNameLen)
+                        maxNameLen = toolName.Length;
+                }
+
+                foreach (var (toolName, toolDesc) in data.Tools)
+                    sb.AppendLine($"  {toolName.PadRight(maxNameLen)}  {toolDesc}");
+            }
+
+            sb.AppendLine();
+            sb.Append($"Package: {data.PackageId}");
+
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Data describing an extension: display info, package ID, and the MCP tools it provides.
+        /// </summary>
+        public readonly struct ExtensionData
+        {
+            public string Name { get; }
+            public string Description { get; }
+            public string PackageId { get; }
+            public string GitUrl { get; }
+            public (string name, string description)[] Tools { get; }
+
+            public ExtensionData(string name, string description, string packageId, string gitUrl, (string name, string description)[] tools)
+            {
+                Name = name;
+                Description = description;
+                PackageId = packageId;
+                GitUrl = gitUrl;
+                Tools = tools;
+            }
+        }
+    }
+}

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

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

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

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

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/UI/Controls/SegmentedControl.cs

@@ -0,0 +1,229 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  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 com.AtelierAI.Unity.Copilot.Editor.Utils;
+using UnityEngine.UIElements;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.UI.Controls
+{
+    /// <summary>
+    /// A segmented control with N segments and a sliding highlight.
+    /// Implements <see cref="INotifyValueChanged{T}"/> for UI Toolkit integration.
+    /// All visual styling is defined in <c>_segmented-control.uss</c>.
+    /// </summary>
+#if UNITY_2023_2_OR_NEWER
+    [UxmlElement]
+    public partial class SegmentedControl : VisualElement, INotifyValueChanged<int>
+#else
+    public class SegmentedControl : VisualElement, INotifyValueChanged<int>
+#endif
+    {
+        private static readonly string[] UssPaths =
+            EditorAssetLoader.GetEditorAssetPaths("Editor/UI/uss/common/_segmented-control.uss");
+
+#if UNITY_2023_2_OR_NEWER
+        [UxmlAttribute("choices")]
+        public string Choices
+        {
+            get => string.Join(",", _segmentLabels);
+            set
+            {
+                if (!string.IsNullOrEmpty(value))
+                {
+                    var labels = value.Split(',');
+                    for (var i = 0; i < labels.Length; i++)
+                        labels[i] = labels[i].Trim();
+                    _segmentLabels = labels;
+                    BuildSegments(labels);
+                }
+            }
+        }
+        private string[] _segmentLabels = Array.Empty<string>();
+
+        [UxmlAttribute("default-index")]
+        public int DefaultIndex
+        {
+            get => _selectedIndex;
+            set => SetValueWithoutNotify(value);
+        }
+#else
+        public new class UxmlFactory : UxmlFactory<SegmentedControl, UxmlTraits> { }
+
+        public new class UxmlTraits : VisualElement.UxmlTraits
+        {
+            private readonly UxmlStringAttributeDescription _choices = new() { name = "choices", defaultValue = "" };
+            private readonly UxmlIntAttributeDescription _defaultIndex = new() { name = "default-index", defaultValue = 0 };
+
+            public override void Init(VisualElement ve, IUxmlAttributes bag, CreationContext cc)
+            {
+                base.Init(ve, bag, cc);
+                var control = (SegmentedControl)ve;
+                var choicesValue = _choices.GetValueFromBag(bag, cc);
+                var defaultIndex = _defaultIndex.GetValueFromBag(bag, cc);
+
+                if (!string.IsNullOrEmpty(choicesValue))
+                {
+                    var labels = choicesValue.Split(',');
+                    for (var i = 0; i < labels.Length; i++)
+                        labels[i] = labels[i].Trim();
+                    control.BuildSegments(labels);
+                    control.SetValueWithoutNotify(defaultIndex);
+                }
+            }
+        }
+#endif
+
+        private readonly VisualElement _track;
+        private readonly VisualElement _highlight;
+        private readonly List<Label> _segments = new();
+        private int _selectedIndex;
+        private bool _transitionReady;
+
+        public int SelectedIndex
+        {
+            get => _selectedIndex;
+            set => SetValue(value);
+        }
+
+        int INotifyValueChanged<int>.value
+        {
+            get => _selectedIndex;
+            set => SetValue(value);
+        }
+
+        public SegmentedControl() : this(Array.Empty<string>()) { }
+
+        public SegmentedControl(params string[] labels)
+        {
+            AddToClassList("segmented-control");
+
+            var uss = EditorAssetLoader.LoadAssetAtPath<StyleSheet>(UssPaths);
+            if (uss != null)
+                styleSheets.Add(uss);
+
+            _track = new VisualElement();
+            _track.AddToClassList("segmented-control__track");
+            Add(_track);
+
+            _highlight = new VisualElement();
+            _highlight.AddToClassList("segmented-control__highlight");
+            _highlight.AddToClassList("segmented-control__highlight--no-transition");
+            _track.Add(_highlight);
+
+            if (labels.Length > 0)
+                BuildSegments(labels);
+        }
+
+        private void BuildSegments(string[] labels)
+        {
+#if UNITY_2023_2_OR_NEWER
+            _segmentLabels = labels;
+#endif
+            // Remove old segments (keep highlight at index 0)
+            foreach (var seg in _segments)
+                _track.Remove(seg);
+            _segments.Clear();
+
+            for (var i = 0; i < labels.Length; i++)
+            {
+                var label = new Label(labels[i]);
+                label.AddToClassList("segmented-control__segment");
+                var index = i;
+                label.RegisterCallback<ClickEvent>(_ => SelectedIndex = index);
+                label.RegisterCallback<GeometryChangedEvent>(_ => SnapHighlightToSegment());
+                _track.Add(label);
+                _segments.Add(label);
+            }
+
+            _transitionReady = false;
+            UpdateHighlight();
+        }
+
+        /// <summary>
+        /// Sets per-segment tooltips. Segment count must match.
+        /// </summary>
+        public void SetTooltips(params string[] tooltips)
+        {
+            for (var i = 0; i < tooltips.Length && i < _segments.Count; i++)
+                _segments[i].tooltip = tooltips[i];
+        }
+
+        public void SetValueWithoutNotify(int newValue)
+        {
+            if (newValue < 0 || (_segments.Count > 0 && newValue >= _segments.Count))
+                return;
+
+            _selectedIndex = newValue;
+            UpdateHighlight();
+        }
+
+        private void SetValue(int newValue)
+        {
+            if (newValue < 0 || (_segments.Count > 0 && newValue >= _segments.Count))
+                return;
+            if (newValue == _selectedIndex)
+                return;
+
+            using var evt = ChangeEvent<int>.GetPooled(_selectedIndex, newValue);
+            evt.target = this;
+            _selectedIndex = newValue;
+            UpdateHighlight();
+            SendEvent(evt);
+        }
+
+        /// <summary>
+        /// Positions the highlight to match the selected segment's actual layout.
+        /// Called on geometry changes and selection changes.
+        /// </summary>
+        private void SnapHighlightToSegment()
+        {
+            if (_segments.Count == 0 || _selectedIndex < 0 || _selectedIndex >= _segments.Count)
+                return;
+
+            var segment = _segments[_selectedIndex];
+            var x = segment.layout.x;
+            var w = segment.layout.width;
+
+            // layout is zero before first layout pass
+            if (float.IsNaN(w) || w <= 0)
+                return;
+
+            _highlight.style.left = x;
+            _highlight.style.width = w;
+        }
+
+        private void UpdateHighlight()
+        {
+            if (_segments.Count == 0)
+                return;
+
+            if (!_transitionReady)
+            {
+                // Start with transitions suppressed; enable after first layout
+                SnapHighlightToSegment();
+                schedule.Execute(() =>
+                {
+                    _transitionReady = true;
+                    _highlight.RemoveFromClassList("segmented-control__highlight--no-transition");
+                });
+            }
+            else
+            {
+                SnapHighlightToSegment();
+            }
+
+            for (var i = 0; i < _segments.Count; i++)
+                _segments[i].EnableInClassList("segmented-control__segment--selected", i == _selectedIndex);
+        }
+    }
+}

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

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

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

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