@atelierai/uco 1.0.0

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/Utils/UnixUtils.cs

@@ -0,0 +1,57 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  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.Runtime.InteropServices;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.Utils
+{
+    public static class UnixUtils
+    {
+        // 0755 in octal (rwxr-xr-x)
+        private const uint MODE_0755 = 0x1ED;
+
+        /// <summary>
+        /// Sets the file permission to 0755 (rwxr-xr-x) on macOS and Linux.
+        /// No-ops on Windows. Throws if the file is missing or chmod fails.
+        /// </summary>
+        public static void Set0755(string path)
+        {
+            if (string.IsNullOrWhiteSpace(path))
+                throw new ArgumentException("Path is null or empty.", nameof(path));
+
+            if (!File.Exists(path))
+                throw new FileNotFoundException("File not found.", path);
+
+            if (!IsUnixLike) return; // Windows: nothing to do
+
+            // Ensure absolute path to avoid surprises
+            var full = Path.GetFullPath(path);
+
+            // P/Invoke chmod (works on both macOS and Linux)
+            int rc = chmod(full, MODE_0755);
+            if (rc != 0)
+            {
+                int errno = Marshal.GetLastWin32Error();
+                throw new InvalidOperationException($"chmod(0755) failed (errno {errno}) for '{full}'.");
+            }
+        }
+
+        private static bool IsUnixLike =>
+            RuntimeInformation.IsOSPlatform(OSPlatform.Linux) ||
+            RuntimeInformation.IsOSPlatform(OSPlatform.OSX);
+
+        // libc is correct on both macOS and Linux for chmod(2)
+        [DllImport("libc", SetLastError = true, CallingConvention = CallingConvention.Cdecl)]
+        private static extern int chmod(string pathname, uint mode);
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/Utils/UnixUtils.cs.meta

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

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/Utils/UpdateChecker.cs

@@ -0,0 +1,421 @@
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  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.Net.Http;
+using System.Text.Json;
+using System.Text.RegularExpressions;
+using System.Threading.Tasks;
+using com.AtelierAI.Unity.Copilot.Editor.UI;
+using Microsoft.Extensions.Logging;
+using UnityEditor;
+using UnityEngine;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.Utils
+{
+    /// <summary>
+    /// Utility class for checking if a new version of the package is available on OpenUPM.
+    /// </summary>
+    /// <remarks>
+    /// OpenUPM is the source of truth for the version that Unity Package Manager will actually
+    /// install for end users. GitHub releases are published before the OpenUPM build pipeline
+    /// finishes, so polling GitHub releases would prompt users to update to a version that is
+    /// not yet installable. See https://github.com/IvanMurzak/uco-plugin/issues/694.
+    ///
+    /// Two opt-out layers gate the popup, in this order:
+    ///   1. <see cref="IsDisabledForProject"/> — team-shared, stored in
+    ///      <c>ProjectSettings/AI-Game-Developer-UpdateSettings.asset</c> via
+    ///      <see cref="UnityCopilotUpdateProjectSettings"/>. Set this once and commit it to
+    ///      disable the popup for every team member who clones the project. See
+    ///      https://github.com/IvanMurzak/uco-plugin/issues/768.
+    ///   2. <see cref="IsDoNotShowAgain"/> — per-user, stored in <see cref="EditorPrefs"/>
+    ///      (NOT <see cref="PlayerPrefs"/> — clearing in-game <c>PlayerPrefs</c> must not
+    ///      wipe the editor flag). See https://github.com/IvanMurzak/uco-plugin/issues/755.
+    /// </remarks>
+    public static class UpdateChecker
+    {
+        private const string PackageId = "com.atelierai.unity.copilot";
+        // package.openupm.com is the npm-style metadata registry (machine-readable JSON);
+        // openupm.com is the human-readable package page the popup links users to.
+        private const string OpenUpmPackageMetadataUrl = "https://package.openupm.com/" + PackageId;
+        private const string OpenUpmPackageUrl = "https://openupm.com/packages/" + PackageId + "/";
+
+        // Anchored at both ends: accepts only complete "N.N" or "N.N.N" strings. Without the
+        // trailing anchor, "1.0.0-preview" would match and CompareVersions would silently
+        // treat the "0-preview" segment as 0, making pre-release tags look equal to the
+        // final release. See https://github.com/IvanMurzak/uco-plugin/issues/694 review.
+        private static readonly Regex VersionPattern = new(@"^\d+\.\d+(\.\d+)?$", RegexOptions.Compiled);
+
+        // Hoisted to a single static instance to avoid socket exhaustion (TIME_WAIT) under
+        // repeated update checks. Same pattern used by NuGetDownloader and DeviceAuthService
+        // elsewhere in this package. The 10s timeout covers OpenUPM's slowest realistic responses.
+        private static readonly HttpClient HttpClient = CreateHttpClient();
+
+        // EditorPrefs is global to the Unity install, so the keys are namespaced by package id
+        // AND by a stable per-project token (FNV-1a hash of Application.dataPath) to keep parallel
+        // projects from stomping on each other's state. See #755 for the migration rationale.
+        //
+        // FNV-1a (not string.GetHashCode()) because Unity is migrating to CoreCLR (preview in 6.x),
+        // and on CoreCLR string.GetHashCode() is randomized per process — keys would change on
+        // every editor restart and per-user state (DoNotShowAgain, cooldown, skipped version)
+        // would be silently lost. FNV-1a is byte-stable across runtimes and across machines.
+        //
+        // Caveat: two distinct Unity projects that happen to live at the same Application.dataPath
+        // (e.g. user copies a project folder, deletes the original, and opens the copy at the same
+        // location) will share EditorPrefs state. Acceptable for a "do not show again" flag.
+        private static readonly string ProjectKeyPrefix =
+            $"{PackageId}.{Fnv1a32(Application.dataPath):X8}.UpdateChecker.";
+        private static readonly string KeyDoNotShowAgain = ProjectKeyPrefix + "DoNotShowAgain";
+        private static readonly string KeyNextCheckTime = ProjectKeyPrefix + "NextCheckTime";
+        private static readonly string KeySkippedVersion = ProjectKeyPrefix + "SkippedVersion";
+
+        /// <summary>
+        /// Deterministic 32-bit FNV-1a hash of a UTF-16 string. Stable across .NET runtimes
+        /// (Mono and CoreCLR) and across machines — unlike <see cref="string.GetHashCode"/>,
+        /// which is randomized per process under CoreCLR.
+        /// </summary>
+        private static uint Fnv1a32(string input)
+        {
+            const uint offsetBasis = 2166136261u;
+            const uint prime = 16777619u;
+            var hash = offsetBasis;
+            for (int i = 0; i < input.Length; i++)
+            {
+                hash ^= (byte)(input[i] & 0xFF);
+                hash *= prime;
+                hash ^= (byte)((input[i] >> 8) & 0xFF);
+                hash *= prime;
+            }
+            return hash;
+        }
+
+        private static bool isChecking = false;
+        private static string? latestVersion = null;
+        private static ILogger? logger = null;
+
+        private static HttpClient CreateHttpClient()
+        {
+            var client = new HttpClient { Timeout = TimeSpan.FromSeconds(10) };
+            client.DefaultRequestHeaders.Add("User-Agent", "AI-Game-Developer-UpdateChecker");
+            return client;
+        }
+
+        /// <summary>
+        /// Gets whether the team-wide kill-switch is enabled for this project. When <c>true</c>,
+        /// the popup is suppressed for every team member who has the
+        /// <c>ProjectSettings/AI-Game-Developer-UpdateSettings.asset</c> file in their checkout,
+        /// regardless of their per-user <see cref="IsDoNotShowAgain"/> state.
+        /// </summary>
+        /// <remarks>
+        /// Stored in <see cref="UnityCopilotUpdateProjectSettings"/> — a <see cref="ScriptableSingleton{T}"/>
+        /// persisted under <c>ProjectSettings/</c>. The asset is intended to be committed to VCS.
+        /// </remarks>
+        public static bool IsDisabledForProject
+        {
+            get => UnityCopilotUpdateProjectSettings.instance.DisableUpdateNotificationsForTeam;
+            set => UnityCopilotUpdateProjectSettings.instance.DisableUpdateNotificationsForTeam = value;
+        }
+
+        /// <summary>
+        /// Gets whether the user has chosen to never show the update popup again on this machine.
+        /// </summary>
+        /// <remarks>
+        /// Stored in <see cref="EditorPrefs"/> (per-user, per-Unity-install) — not in
+        /// <see cref="PlayerPrefs"/>. Clearing in-game <c>PlayerPrefs</c> must not silently
+        /// reset the editor flag. See https://github.com/IvanMurzak/uco-plugin/issues/755.
+        /// </remarks>
+        public static bool IsDoNotShowAgain
+        {
+            get => EditorPrefs.GetBool(KeyDoNotShowAgain, false);
+            set => EditorPrefs.SetBool(KeyDoNotShowAgain, value);
+        }
+
+        /// <summary>
+        /// Gets the latest version that was found during the last check.
+        /// </summary>
+        public static string? LatestVersion => latestVersion;
+
+        /// <summary>
+        /// Gets the OpenUPM package URL for the user to manually view available versions.
+        /// </summary>
+        /// <remarks>
+        /// Points at OpenUPM rather than GitHub releases because OpenUPM is the registry
+        /// Unity Package Manager actually pulls from — the version visible there is the
+        /// version users can actually install at this moment.
+        /// </remarks>
+        public static string ReleasesUrl => OpenUpmPackageUrl;
+
+        public static void Init(ILogger? initLogger = null)
+        {
+            logger = initLogger;
+
+            // Check for updates after Unity finishes loading
+            EditorApplication.delayCall += CheckForUpdatesOnStartup;
+        }
+
+        private static void CheckForUpdatesOnStartup()
+        {
+            EditorApplication.delayCall -= CheckForUpdatesOnStartup;
+
+            if (!ShouldCheckForUpdates())
+                return;
+
+            _ = CheckForUpdatesAsync();
+        }
+
+        /// <summary>
+        /// Determines if we should check for updates based on the team-shared project flag,
+        /// the per-user opt-out, and the cooldown timer.
+        /// </summary>
+        /// <remarks>
+        /// Precedence (in order):
+        ///   1. <see cref="IsDisabledForProject"/> — team-wide kill-switch wins over everything.
+        ///   2. <see cref="IsDoNotShowAgain"/> — per-user opt-out.
+        ///   3. The cooldown timestamp stored in <see cref="EditorPrefs"/>.
+        /// </remarks>
+        public static bool ShouldCheckForUpdates()
+        {
+            // 1. Team-wide kill-switch — short-circuits before any per-user state is consulted.
+            if (IsDisabledForProject)
+                return false;
+
+            // 2. Per-user opt-out.
+            if (IsDoNotShowAgain)
+                return false;
+
+            // 3. Cooldown.
+            var nextCheckTimeStr = EditorPrefs.GetString(KeyNextCheckTime, string.Empty);
+            if (!string.IsNullOrEmpty(nextCheckTimeStr))
+            {
+                if (DateTime.TryParse(nextCheckTimeStr, out var nextCheckDateTime))
+                {
+                    if (DateTime.UtcNow < nextCheckDateTime)
+                        return false;
+                }
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Skips a specific version (user doesn't want to be notified about it again).
+        /// </summary>
+        public static void SkipVersion(string version)
+        {
+            EditorPrefs.SetString(KeySkippedVersion, version);
+        }
+
+        /// <summary>
+        /// Clears all per-user update-checker preferences (useful for testing and for the
+        /// "Reset Update Preferences" debug menu).
+        /// </summary>
+        /// <remarks>
+        /// This intentionally does NOT reset <see cref="IsDisabledForProject"/> — that flag is
+        /// team-shared via <c>ProjectSettings/</c>, and clearing it from a debug menu would
+        /// produce a spurious diff in a committed asset (potentially surprising other team
+        /// members). The team flag is reset only through the Project Settings UI or
+        /// <c>Tools ▸ AI Game Developer ▸ Updates ▸ Disable Update Notifications (Team)</c>.
+        /// </remarks>
+        public static void ClearPreferences()
+        {
+            EditorPrefs.DeleteKey(KeyDoNotShowAgain);
+            EditorPrefs.DeleteKey(KeyNextCheckTime);
+            EditorPrefs.DeleteKey(KeySkippedVersion);
+        }
+
+        /// <summary>
+        /// Asynchronously checks for updates from OpenUPM.
+        /// </summary>
+        /// <param name="forceCheck">If true, ignores cooldown and skipped version settings.</param>
+        public static async Task CheckForUpdatesAsync(bool forceCheck = false)
+        {
+            if (isChecking)
+            {
+                if (forceCheck)
+                    logger?.LogWarning("Already checking for updates...");
+                return;
+            }
+
+            if (!forceCheck && !ShouldCheckForUpdates())
+                return;
+
+            isChecking = true;
+
+            try
+            {
+                var fetched = await FetchLatestVersionAsync();
+                if (string.IsNullOrEmpty(fetched))
+                {
+                    if (forceCheck)
+                        logger?.LogWarning("Unable to check for updates. Please check your internet connection.");
+                    return;
+                }
+
+                latestVersion = fetched;
+
+                // Check if this version was skipped
+                var skippedVersion = EditorPrefs.GetString(KeySkippedVersion, string.Empty);
+                if (!string.IsNullOrEmpty(skippedVersion) && skippedVersion == fetched && !forceCheck)
+                {
+                    return;
+                }
+
+                // Compare versions. The `!` is required because the Unity Editor C# compiler
+                // does not honor `[NotNullWhen(false)]` on `string.IsNullOrEmpty`, so it does
+                // not narrow `fetched` (declared `string?`) to non-null after the early-return
+                // guard above and would otherwise emit CS8604 here. The runtime check above
+                // already establishes `fetched` is non-null and non-empty at this point.
+                var currentVersion = UnityCopilotPlugin.Version;
+                if (IsNewerVersion(fetched!, currentVersion))
+                {
+                    // Show the update popup on the main thread
+                    EditorApplication.delayCall += () =>
+                    {
+                        UpdatePopupWindow.ShowWindow(currentVersion, fetched!);
+                    };
+                }
+                else if (forceCheck)
+                {
+                    // User manually checked - inform them they're up to date
+                    logger?.LogDebug("You are using the latest version ({currentVersion}).", currentVersion);
+                }
+            }
+            catch (Exception ex)
+            {
+                logger?.LogWarning(ex, "Failed to check for updates");
+            }
+            finally
+            {
+                // Set next allowed check time to enforce cooldown (only for automatic checks)
+                if (!forceCheck)
+                {
+                    EditorPrefs.SetString(KeyNextCheckTime, DateTime.UtcNow.AddHours(1).ToString("O"));
+                }
+                isChecking = false;
+            }
+        }
+
+        /// <summary>
+        /// Fetches the latest version from the OpenUPM registry.
+        /// </summary>
+        /// <remarks>
+        /// Uses the npm-style registry endpoint <c>https://package.openupm.com/{packageId}</c>,
+        /// which returns a JSON document whose <c>dist-tags.latest</c> field is the version
+        /// currently installable via Unity Package Manager. On any network or parsing failure
+        /// the method returns <c>null</c> so callers fall back gracefully without prompting.
+        /// </remarks>
+        private static async Task<string?> FetchLatestVersionAsync()
+        {
+            try
+            {
+                var json = await HttpClient.GetStringAsync(OpenUpmPackageMetadataUrl);
+                return ParseLatestVersionFromJson(json);
+            }
+            catch (HttpRequestException ex)
+            {
+                // Use the exception-preserving overload so stack trace and inner exceptions
+                // survive into structured logs — same pattern as the catch-all below.
+                logger?.LogWarning(ex, "Failed to fetch package metadata");
+                return null;
+            }
+            catch (TaskCanceledException ex)
+            {
+                logger?.LogWarning(ex, "OpenUPM request timed out");
+                return null;
+            }
+            catch (Exception ex)
+            {
+                // ParseLatestVersionFromJson swallows JsonException internally, so anything
+                // reaching here is an unexpected transport / URI / IO failure rather than a
+                // parse error — message must reflect that.
+                logger?.LogWarning(ex, "Unexpected error during OpenUPM update check");
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Parses the latest version from an OpenUPM registry JSON response.
+        /// </summary>
+        /// <remarks>
+        /// The OpenUPM registry follows the npm registry shape; the latest published version
+        /// is at <c>dist-tags.latest</c>. Returns <c>null</c> if the JSON is empty, malformed,
+        /// or does not contain a <c>dist-tags.latest</c> string. Also returns <c>null</c> for
+        /// non-numeric or pre-release version strings (e.g. <c>"1.0.0-preview"</c>) — the
+        /// parser only accepts strict <c>N.N</c> / <c>N.N.N</c> shapes so the popup never
+        /// surfaces a tag that <see cref="CompareVersions"/> would silently misorder.
+        /// </remarks>
+        internal static string? ParseLatestVersionFromJson(string json)
+        {
+            if (string.IsNullOrEmpty(json))
+                return null;
+
+            try
+            {
+                using var doc = JsonDocument.Parse(json);
+
+                if (!doc.RootElement.TryGetProperty("dist-tags", out var distTags))
+                    return null;
+
+                if (distTags.ValueKind != JsonValueKind.Object)
+                    return null;
+
+                if (!distTags.TryGetProperty("latest", out var latest))
+                    return null;
+
+                if (latest.ValueKind != JsonValueKind.String)
+                    return null;
+
+                var version = latest.GetString();
+                if (string.IsNullOrEmpty(version))
+                    return null;
+
+                // Defensive: only accept numeric semver-shaped strings. Without this guard
+                // CompareVersions would silently treat non-numeric parts as 0, producing a
+                // misleading "version" in the popup if the registry ever returns garbage.
+                return VersionPattern.IsMatch(version) ? version : null;
+            }
+            catch (JsonException)
+            {
+                return null;
+            }
+        }
+
+        /// <summary>
+        /// Compares two version strings.
+        /// </summary>
+        internal static int CompareVersions(string v1, string v2)
+        {
+            var parts1 = v1.Split('.');
+            var parts2 = v2.Split('.');
+
+            var maxLength = Math.Max(parts1.Length, parts2.Length);
+            for (int i = 0; i < maxLength; i++)
+            {
+                var num1 = i < parts1.Length && int.TryParse(parts1[i], out var n1) ? n1 : 0;
+                var num2 = i < parts2.Length && int.TryParse(parts2[i], out var n2) ? n2 : 0;
+
+                if (num1 != num2)
+                    return num1.CompareTo(num2);
+            }
+
+            return 0;
+        }
+
+        /// <summary>
+        /// Determines if the remote version is newer than the current version.
+        /// </summary>
+        public static bool IsNewerVersion(string remoteVersion, string currentVersion)
+        {
+            return CompareVersions(remoteVersion, currentVersion) > 0;
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/Utils/UpdateChecker.cs.meta

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

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

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

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/com.AtelierAI.Unity.Copilot.Editor.asmdef

@@ -0,0 +1,32 @@
+{
+    "name": "com.AtelierAI.Unity.Copilot.Editor",
+    "rootNamespace": "com.AtelierAI.Unity.Copilot.Editor",
+    "references": [
+        "com.AtelierAI.Unity.Copilot.Runtime",
+        "com.AtelierAI.Unity.Copilot.DependencyResolver"
+    ],
+    "includePlatforms": [
+        "Editor"
+    ],
+    "excludePlatforms": [],
+    "allowUnsafeCode": false,
+    "overrideReferences": true,
+    "precompiledReferences": [
+        "ReflectorNet.dll",
+        "Uco.Framework.dll",
+        "Uco.Framework.Common.dll",
+        "R3.dll",
+        "Microsoft.Extensions.Logging.Abstractions.dll",
+        "Microsoft.Extensions.Logging.dll",
+        "Microsoft.CodeAnalysis.CSharp.dll",
+        "Microsoft.CodeAnalysis.dll",
+        "System.Collections.Immutable.dll",
+        "System.Text.Json.dll"
+    ],
+    "autoReferenced": true,
+    "defineConstraints": [
+        "UNITY_COPILOT_READY"
+    ],
+    "versionDefines": [],
+    "noEngineReferences": false
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/Scripts/com.AtelierAI.Unity.Copilot.Editor.asmdef.meta

@@ -0,0 +1,7 @@
+fileFormatVersion: 2
+guid: 467d1292373935c4b9daa95152bf595c
+AssemblyDefinitionImporter:
+  externalObjects: {}
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 

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

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

package/vendor/plugin/com.atelierai.unity.copilot/Editor/UI/uss/CopilotPromptsWindow.uss

@@ -0,0 +1,11 @@
+/* ==========================================================================
+   MCP Prompts Window Styles
+   Imports common list window styles and adds prompt-specific customizations
+   ========================================================================== */
+
+@import url("common/_mcp-list-window.uss");
+
+/* Prompt-specific: Role label color */
+.item-role {
+    color: #8FAADC;
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 7acdb2708e8926643956ed3c8d749d9f
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0

package/vendor/plugin/com.atelierai.unity.copilot/Editor/UI/uss/CopilotResourcesWindow.uss

@@ -0,0 +1,16 @@
+/* ==========================================================================
+   MCP Resources Window Styles
+   Imports common list window styles and adds resource-specific customizations
+   ========================================================================== */
+
+@import url("common/_mcp-list-window.uss");
+
+/* Resource-specific: URI label color */
+.item-uri {
+    color: #9ACD32;
+}
+
+/* Resource-specific: MIME type label color */
+.item-mimetype {
+    color: #DDA0DD;
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 1bfb2aeefa7c39c4c990c11607ef0d8a
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0

package/vendor/plugin/com.atelierai.unity.copilot/Editor/UI/uss/CopilotToolsWindow.uss

@@ -0,0 +1,36 @@
+/* ==========================================================================
+   MCP Tools Window Styles
+   ========================================================================== */
+
+@import url("common/_mcp-list-window.uss");
+
+/* Tool Item Header - column layout with two rows */
+.tool-item-header {
+    flex-direction: column;
+}
+
+/* Shared row style for tool item rows */
+.tool-item-row {
+    flex-direction: row;
+    justify-content: space-between;
+    width: 100%;
+}
+
+/* Title row - toggle aligned to top */
+.tool-item-title-row {
+    align-items: flex-start;
+}
+
+/* Subtitle row - vertically centered */
+.tool-item-subtitle-row {
+    align-items: center;
+}
+
+/* Token Count */
+.item-token-count {
+    flex-shrink: 0;
+    margin-left: 8px;
+    font-size: 10px;
+    color: rgb(150, 150, 150);
+    white-space: nowrap;
+}

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

@@ -0,0 +1,11 @@
+fileFormatVersion: 2
+guid: 525911ffb58076f44a1788589abac01d
+ScriptedImporter:
+  internalIDToNameTable: []
+  externalObjects: {}
+  serializedVersion: 2
+  userData: 
+  assetBundleName: 
+  assetBundleVariant: 
+  script: {fileID: 12385, guid: 0000000000000000e000000000000000, type: 0}
+  disableValidation: 0