@atelierai/uco 1.0.7 → 1.0.9

package/vendor/plugin/com.atelierai.unity.copilot/Runtime/UnityCopilotPlugin.Build.cs

@@ -1,243 +1,243 @@
-/*
-┌──────────────────────────────────────────────────────────────────┐
-│  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.Linq;
-using com.AtelierAI.Uco.Framework;
-using com.IvanMurzak.ReflectorNet;
-using com.IvanMurzak.ReflectorNet.Utils;
-using com.AtelierAI.Unity.Copilot.Runtime.Utils;
-using com.AtelierAI.Unity.Copilot.Utils;
-using Microsoft.Extensions.Logging;
-using R3;
-using UnityEngine;
-using ILogger = Microsoft.Extensions.Logging.ILogger;
-
-namespace com.AtelierAI.Unity.Copilot
-{
-    using Consts = com.AtelierAI.Uco.Framework.Common.Consts;
-    using MicrosoftLogLevel = Microsoft.Extensions.Logging.LogLevel;
-
-    public partial class UnityCopilotPlugin
-    {
-        static readonly ILogger _logger = UnityLoggerFactory.LoggerFactory.CreateLogger<UnityCopilotPlugin>();
-
-        protected sealed class CopilotPluginSlot : IDisposable
-        {
-            private readonly object _mutex = new();
-            private IUcoPlugin? _instance;
-
-            public IUcoPlugin? Instance
-            {
-                get { lock (_mutex) { return _instance; } }
-            }
-
-            public bool HasInstance
-            {
-                get { lock (_mutex) { return _instance != null; } }
-            }
-
-            // Calls factory inside lock — guarantees build-once under concurrent access.
-            // Returns the built instance if it was just created, null if already built.
-            public IUcoPlugin? BuildOnce(Func<IUcoPlugin> factory)
-            {
-                lock (_mutex)
-                {
-                    if (_instance != null) return null;
-                    _instance = factory();
-                    return _instance;
-                }
-            }
-
-            // Disposes old instance (if any), sets new one, returns it.
-            public IUcoPlugin Set(IUcoPlugin plugin)
-            {
-                lock (_mutex)
-                {
-                    _instance?.Dispose();
-                    _instance = plugin;
-                    return plugin;
-                }
-            }
-
-            // Atomically returns and clears the instance without disposing it.
-            // Used by callers that need to control when/how disposal happens (e.g. background thread).
-            public IUcoPlugin? TakeInstance()
-            {
-                lock (_mutex)
-                {
-                    var instance = _instance;
-                    _instance = null;
-                    return instance;
-                }
-            }
-
-            public void Dispose()
-            {
-                lock (_mutex)
-                {
-                    _instance?.Dispose();
-                    _instance = null;
-                }
-            }
-        }
-
-        protected virtual com.AtelierAI.Uco.Framework.Common.Version BuildVersion()
-        {
-            return new com.AtelierAI.Uco.Framework.Common.Version
-            {
-                Api = Consts.ApiVersion,
-                Plugin = UnityCopilotPlugin.Version,
-                Environment = Application.unityVersion
-            };
-        }
-
-        protected virtual ILoggerProvider? BuildLoggerProvider()
-        {
-            return new UnityLoggerProvider();
-        }
-
-        protected virtual IUcoPlugin BuildMcpPlugin(
-            com.AtelierAI.Uco.Framework.Common.Version version,
-            Reflector reflector,
-            ILoggerProvider? loggerProvider = null,
-            Action<IMcpPluginBuilder>? configure = null)
-        {
-            _logger.LogTrace("{method} called.", nameof(BuildMcpPlugin));
-
-            var assemblies = AssemblyUtils.AllAssemblies;
-            var mcpPluginBuilder = new UcoBuilder(version, loggerProvider)
-                .WithProjectPathPolicy(new ProjectPathPolicy(
-                    System.IO.Directory.GetParent(Application.dataPath)?.FullName
-                    ?? Application.dataPath))
-                .SetConfig(unityConnectionConfig ?? throw new InvalidOperationException("UnityConnectionConfig must be set before building the plugin."))
-                .AddLogging(loggingBuilder =>
-                {
-                    loggingBuilder.ClearProviders(); // 👈 Clears the default providers
-                    loggingBuilder.SetMinimumLevel(MicrosoftLogLevel.Trace);
-
-                    if (loggerProvider != null)
-                        loggingBuilder.AddProvider(loggerProvider);
-                })
-                .IgnoreAssemblies(
-                    "mscorlib",
-                    "Mono.Security",
-                    "netstandard",
-                    "nunit.framework",
-                    "System",
-                    "UnityEngine",
-                    "UnityEditor",
-                    "Unity.",
-                    "Microsoft",
-                    "R3",
-                    "UcoFramework",
-                    "ReflectorNet",
-                    "com.AtelierAI.Unity.Copilot.TestFiles",
-                    "com.AtelierAI.Unity.Copilot.Editor.Tests",
-                    "com.AtelierAI.Unity.Copilot.Tests")
-                .WithToolsFromAssembly(assemblies)
-                .WithPromptsFromAssembly(assemblies)
-                .WithResourcesFromAssembly(assemblies)
-                .WithSkillsFromAssembly(assemblies);
-
-            configure?.Invoke(mcpPluginBuilder);
-
-            var mcpPlugin = mcpPluginBuilder.Build(reflector);
-
-            _pluginConnectionSubscription?.Dispose();
-            _pluginConnectionSubscription = mcpPlugin.ConnectionState
-                .Subscribe(state => _connectionState.Value = state);
-
-            _logger.LogTrace("{method} completed.", nameof(BuildMcpPlugin));
-
-            return mcpPlugin;
-        }
-
-        protected virtual void ApplyConfigToMcpPlugin(IUcoPlugin mcpPlugin)
-        {
-            _logger.LogTrace("{method} called.", nameof(ApplyConfigToMcpPlugin));
-
-            // Enable/Disable tools based on config
-            var toolManager = mcpPlugin.UcoManager.ToolManager;
-            if (toolManager != null)
-            {
-                var enabledToolsOverride = unityConnectionConfig.EnabledToolsOverride;
-                if (enabledToolsOverride != null)
-                {
-                    var allTools = toolManager.GetAllTools().ToList();
-                    var enabledSet = new HashSet<string>(enabledToolsOverride, StringComparer.OrdinalIgnoreCase);
-
-                    // Validate requested tool IDs against the registered tool list
-                    var allToolNames = new HashSet<string>(
-                        allTools.Select(t => t.Name!),
-                        StringComparer.OrdinalIgnoreCase);
-                    foreach (var requestedId in enabledToolsOverride)
-                    {
-                        if (!allToolNames.Contains(requestedId))
-                            _logger.LogError("[MCP] {Key}: tool '{ToolId}' not found. Check the tool ID.",
-                                EnvironmentUtils.EnvTools, requestedId);
-                    }
-
-                    // Apply: enable only tools in the override list, disable all others
-                    foreach (var tool in allTools)
-                    {
-                        var isEnabled = enabledSet.Contains(tool.Name!);
-                        toolManager.SetToolEnabled(tool.Name!, isEnabled);
-                        _logger.LogDebug("{method}: Tool '{tool}' enabled: {isEnabled} (env override)",
-                            nameof(ApplyConfigToMcpPlugin), tool.Name, isEnabled);
-                    }
-                }
-                else
-                {
-                    foreach (var tool in toolManager.GetAllTools())
-                    {
-                        var toolFeature = unityConnectionConfig.Tools.FirstOrDefault(t => t.Name == tool.Name!);
-                        var isEnabled = toolFeature?.Enabled ?? tool.Enabled;
-                        toolManager.SetToolEnabled(tool.Name!, isEnabled);
-                        _logger.LogDebug("{method}: Tool '{tool}' enabled: {isEnabled}",
-                            nameof(ApplyConfigToMcpPlugin), tool.Name, isEnabled);
-                    }
-                }
-            }
-
-            // Enable/Disable prompts based on config
-            var promptManager = mcpPlugin.UcoManager.PromptManager;
-            if (promptManager != null)
-            {
-                foreach (var prompt in promptManager.GetAllPrompts())
-                {
-                    var promptFeature = unityConnectionConfig.Prompts.FirstOrDefault(p => p.Name == prompt.Name);
-                    var isEnabled = promptFeature?.Enabled ?? prompt.Enabled;
-                    promptManager.SetPromptEnabled(prompt.Name, isEnabled);
-                    _logger.LogDebug("{method}: Prompt '{prompt}' enabled: {isEnabled}",
-                        nameof(ApplyConfigToMcpPlugin), prompt.Name, isEnabled);
-                }
-            }
-
-            // Enable/Disable resources based on config
-            var resourceManager = mcpPlugin.UcoManager.ResourceManager;
-            if (resourceManager != null)
-            {
-                foreach (var resource in resourceManager.GetAllResources())
-                {
-                    var resourceFeature = unityConnectionConfig.Resources.FirstOrDefault(r => r.Name == resource.Name);
-                    var isEnabled = resourceFeature?.Enabled ?? resource.Enabled;
-                    resourceManager.SetResourceEnabled(resource.Name, isEnabled);
-                    _logger.LogDebug("{method}: Resource '{resource}' enabled: {isEnabled}",
-                        nameof(ApplyConfigToMcpPlugin), resource.Name, isEnabled);
-                }
-            }
-
-            _logger.LogTrace("{method} completed.", nameof(ApplyConfigToMcpPlugin));
-        }
-    }
-}
+/*
+┌──────────────────────────────────────────────────────────────────┐
+│  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.Linq;
+using com.AtelierAI.Uco.Framework;
+using com.IvanMurzak.ReflectorNet;
+using com.IvanMurzak.ReflectorNet.Utils;
+using com.AtelierAI.Unity.Copilot.Runtime.Utils;
+using com.AtelierAI.Unity.Copilot.Utils;
+using Microsoft.Extensions.Logging;
+using R3;
+using UnityEngine;
+using ILogger = Microsoft.Extensions.Logging.ILogger;
+
+namespace com.AtelierAI.Unity.Copilot
+{
+    using Consts = com.AtelierAI.Uco.Framework.Common.Consts;
+    using MicrosoftLogLevel = Microsoft.Extensions.Logging.LogLevel;
+
+    public partial class UnityCopilotPlugin
+    {
+        static readonly ILogger _logger = UnityLoggerFactory.LoggerFactory.CreateLogger<UnityCopilotPlugin>();
+
+        protected sealed class CopilotPluginSlot : IDisposable
+        {
+            private readonly object _mutex = new();
+            private IUcoPlugin? _instance;
+
+            public IUcoPlugin? Instance
+            {
+                get { lock (_mutex) { return _instance; } }
+            }
+
+            public bool HasInstance
+            {
+                get { lock (_mutex) { return _instance != null; } }
+            }
+
+            // Calls factory inside lock — guarantees build-once under concurrent access.
+            // Returns the built instance if it was just created, null if already built.
+            public IUcoPlugin? BuildOnce(Func<IUcoPlugin> factory)
+            {
+                lock (_mutex)
+                {
+                    if (_instance != null) return null;
+                    _instance = factory();
+                    return _instance;
+                }
+            }
+
+            // Disposes old instance (if any), sets new one, returns it.
+            public IUcoPlugin Set(IUcoPlugin plugin)
+            {
+                lock (_mutex)
+                {
+                    _instance?.Dispose();
+                    _instance = plugin;
+                    return plugin;
+                }
+            }
+
+            // Atomically returns and clears the instance without disposing it.
+            // Used by callers that need to control when/how disposal happens (e.g. background thread).
+            public IUcoPlugin? TakeInstance()
+            {
+                lock (_mutex)
+                {
+                    var instance = _instance;
+                    _instance = null;
+                    return instance;
+                }
+            }
+
+            public void Dispose()
+            {
+                lock (_mutex)
+                {
+                    _instance?.Dispose();
+                    _instance = null;
+                }
+            }
+        }
+
+        protected virtual com.AtelierAI.Uco.Framework.Common.Version BuildVersion()
+        {
+            return new com.AtelierAI.Uco.Framework.Common.Version
+            {
+                Api = Consts.ApiVersion,
+                Plugin = UnityCopilotPlugin.Version,
+                Environment = Application.unityVersion
+            };
+        }
+
+        protected virtual ILoggerProvider? BuildLoggerProvider()
+        {
+            return new UnityLoggerProvider();
+        }
+
+        protected virtual IUcoPlugin BuildUcoPlugin(
+            com.AtelierAI.Uco.Framework.Common.Version version,
+            Reflector reflector,
+            ILoggerProvider? loggerProvider = null,
+            Action<IUcoPluginBuilder>? configure = null)
+        {
+            _logger.LogTrace("{method} called.", nameof(BuildUcoPlugin));
+
+            var assemblies = AssemblyUtils.AllAssemblies;
+            var ucoPluginBuilder = new UcoBuilder(version, loggerProvider)
+                .WithProjectPathPolicy(new ProjectPathPolicy(
+                    System.IO.Directory.GetParent(Application.dataPath)?.FullName
+                    ?? Application.dataPath))
+                .SetConfig(unityConnectionConfig ?? throw new InvalidOperationException("UnityConnectionConfig must be set before building the plugin."))
+                .AddLogging(loggingBuilder =>
+                {
+                    loggingBuilder.ClearProviders(); // 👈 Clears the default providers
+                    loggingBuilder.SetMinimumLevel(MicrosoftLogLevel.Trace);
+
+                    if (loggerProvider != null)
+                        loggingBuilder.AddProvider(loggerProvider);
+                })
+                .IgnoreAssemblies(
+                    "mscorlib",
+                    "Mono.Security",
+                    "netstandard",
+                    "nunit.framework",
+                    "System",
+                    "UnityEngine",
+                    "UnityEditor",
+                    "Unity.",
+                    "Microsoft",
+                    "R3",
+                    "UcoFramework",
+                    "ReflectorNet",
+                    "com.AtelierAI.Unity.Copilot.TestFiles",
+                    "com.AtelierAI.Unity.Copilot.Editor.Tests",
+                    "com.AtelierAI.Unity.Copilot.Tests")
+                .WithToolsFromAssembly(assemblies)
+                .WithPromptsFromAssembly(assemblies)
+                .WithResourcesFromAssembly(assemblies)
+                .WithSkillsFromAssembly(assemblies);
+
+            configure?.Invoke(ucoPluginBuilder);
+
+            var ucoPlugin = ucoPluginBuilder.Build(reflector);
+
+            _pluginConnectionSubscription?.Dispose();
+            _pluginConnectionSubscription = ucoPlugin.ConnectionState
+                .Subscribe(state => _connectionState.Value = state);
+
+            _logger.LogTrace("{method} completed.", nameof(BuildUcoPlugin));
+
+            return ucoPlugin;
+        }
+
+        protected virtual void ApplyConfigToUcoPlugin(IUcoPlugin ucoPlugin)
+        {
+            _logger.LogTrace("{method} called.", nameof(ApplyConfigToUcoPlugin));
+
+            // Enable/Disable tools based on config
+            var toolManager = ucoPlugin.UcoManager.ToolManager;
+            if (toolManager != null)
+            {
+                var enabledToolsOverride = unityConnectionConfig.EnabledToolsOverride;
+                if (enabledToolsOverride != null)
+                {
+                    var allTools = toolManager.GetAllTools().ToList();
+                    var enabledSet = new HashSet<string>(enabledToolsOverride, StringComparer.OrdinalIgnoreCase);
+
+                    // Validate requested tool IDs against the registered tool list
+                    var allToolNames = new HashSet<string>(
+                        allTools.Select(t => t.Name!),
+                        StringComparer.OrdinalIgnoreCase);
+                    foreach (var requestedId in enabledToolsOverride)
+                    {
+                        if (!allToolNames.Contains(requestedId))
+                            _logger.LogError("[Uco] {Key}: tool '{ToolId}' not found. Check the tool ID.",
+                                EnvironmentUtils.EnvTools, requestedId);
+                    }
+
+                    // Apply: enable only tools in the override list, disable all others
+                    foreach (var tool in allTools)
+                    {
+                        var isEnabled = enabledSet.Contains(tool.Name!);
+                        toolManager.SetToolEnabled(tool.Name!, isEnabled);
+                        _logger.LogDebug("{method}: Tool '{tool}' enabled: {isEnabled} (env override)",
+                            nameof(ApplyConfigToUcoPlugin), tool.Name, isEnabled);
+                    }
+                }
+                else
+                {
+                    foreach (var tool in toolManager.GetAllTools())
+                    {
+                        var toolFeature = unityConnectionConfig.Tools.FirstOrDefault(t => t.Name == tool.Name!);
+                        var isEnabled = toolFeature?.Enabled ?? tool.Enabled;
+                        toolManager.SetToolEnabled(tool.Name!, isEnabled);
+                        _logger.LogDebug("{method}: Tool '{tool}' enabled: {isEnabled}",
+                            nameof(ApplyConfigToUcoPlugin), tool.Name, isEnabled);
+                    }
+                }
+            }
+
+            // Enable/Disable prompts based on config
+            var promptManager = ucoPlugin.UcoManager.PromptManager;
+            if (promptManager != null)
+            {
+                foreach (var prompt in promptManager.GetAllPrompts())
+                {
+                    var promptFeature = unityConnectionConfig.Prompts.FirstOrDefault(p => p.Name == prompt.Name);
+                    var isEnabled = promptFeature?.Enabled ?? prompt.Enabled;
+                    promptManager.SetPromptEnabled(prompt.Name, isEnabled);
+                    _logger.LogDebug("{method}: Prompt '{prompt}' enabled: {isEnabled}",
+                        nameof(ApplyConfigToUcoPlugin), prompt.Name, isEnabled);
+                }
+            }
+
+            // Enable/Disable resources based on config
+            var resourceManager = ucoPlugin.UcoManager.ResourceManager;
+            if (resourceManager != null)
+            {
+                foreach (var resource in resourceManager.GetAllResources())
+                {
+                    var resourceFeature = unityConnectionConfig.Resources.FirstOrDefault(r => r.Name == resource.Name);
+                    var isEnabled = resourceFeature?.Enabled ?? resource.Enabled;
+                    resourceManager.SetResourceEnabled(resource.Name, isEnabled);
+                    _logger.LogDebug("{method}: Resource '{resource}' enabled: {isEnabled}",
+                        nameof(ApplyConfigToUcoPlugin), resource.Name, isEnabled);
+                }
+            }
+
+            _logger.LogTrace("{method} completed.", nameof(ApplyConfigToUcoPlugin));
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Runtime/UnityCopilotPlugin.Config.cs

@@ -16,7 +16,7 @@ using com.AtelierAI.Uco.Framework;
 using com.AtelierAI.Uco.Framework.Common;
 using com.AtelierAI.Uco.Framework.Common.Utils;
 using com.AtelierAI.Unity.Copilot.Runtime.Utils;
-using static com.AtelierAI.Uco.Framework.Common.Consts.MCP.Server;
+using static com.AtelierAI.Uco.Framework.Common.Consts.Uco.Server;
 
 namespace com.AtelierAI.Unity.Copilot
 {
@@ -67,7 +67,7 @@ namespace com.AtelierAI.Unity.Copilot
             public ConnectionMode ConnectionMode { get; set; } = ConnectionMode.Custom;
 
             /// <summary>
-            /// Optional path to the Node.js MCP server entry script (cocli's bin/server.mjs).
+            /// Optional path to the Node.js Uco server entry script (cocli's bin/server.mjs).
             /// Absolute path, or relative to the Unity project root. When null/empty the
             /// plugin auto-discovers the server (the Unity project's node_modules, then the
             /// npm global installation). When set, the path must exist or the plugin refuses
@@ -94,7 +94,7 @@ namespace com.AtelierAI.Unity.Copilot
 
             /// <summary>
             /// When false (the safe default for new configs), the plugin refuses to start the
-            /// local MCP server if <see cref="LocalHost"/> resolves to a non-loopback address
+            /// local Uco server if <see cref="LocalHost"/> resolves to a non-loopback address
             /// (e.g. <c>0.0.0.0</c>, <c>::</c>, or a LAN IP). Set to true to opt in to binding
             /// the server on every interface so other machines on the LAN can connect.
             /// </summary>