@atelierai/uco 1.0.0

package/vendor/plugin/com.atelierai.unity.copilot/Editor/DependencyResolver/NuGetPackageRestorer.cs

@@ -0,0 +1,267 @@
+/*
++------------------------------------------------------------------+
+|  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.IO;
+using System.Linq;
+using UnityEngine;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.DependencyResolver
+{
+    /// <summary>
+    /// Restores NuGet packages on domain reload.
+    /// Compares the required packages (from NuGetConfig) against the on-disk manifest at
+    /// <c>Assets/Plugins/NuGet/.nuget-installed.json</c>. Downloads and installs any missing
+    /// packages. Also removes packages that Unity now provides natively.
+    ///
+    /// Since #733 the on-disk layout is flat — see <see cref="NuGetExtractor"/> and
+    /// <see cref="NuGetInstallManifest"/>. The restorer also runs the one-shot
+    /// migration from the legacy per-package layout via <see cref="NuGetLegacyMigration"/>
+    /// at the start of every Restore() pass; the migration is idempotent and is a
+    /// no-op once the legacy folders are gone.
+    /// </summary>
+    static class NuGetPackageRestorer
+    {
+        const string Tag = NuGetConfig.LogTag;
+
+        /// <summary>
+        /// Performs a full package restore. Returns true if any packages were installed
+        /// or removed (meaning a domain reload is needed).
+        /// </summary>
+        public static bool Restore()
+        {
+            var anyChanged = false;
+
+            try
+            {
+                NuGetPackageInstaller.ResetSession();
+
+                // Ensure install directory exists
+                if (!Directory.Exists(NuGetConfig.InstallPath))
+                    Directory.CreateDirectory(NuGetConfig.InstallPath);
+
+                // Best-effort: continue past AbortedFileLock so extraction can proceed
+                // on what the migration freed up; the rest finishes on the next reload.
+                var migration = NuGetLegacyMigration.Run(NuGetConfig.InstallPath);
+                if (migration.Outcome != NuGetLegacyMigration.Outcome.NoLegacyState)
+                    anyChanged = true;
+
+                // Manifest disaster recovery: rebuild from on-disk versioned
+                // filenames when .nuget-installed.json is missing. The
+                // {stem}.{packageVersion}.dll pattern carries enough metadata
+                // for TryRebuildFromDisk to reconstruct a manifest matching the
+                // steady state, so Install()'s alreadyOnDisk check then short-
+                // circuits and no re-extraction churn happens. Persist the
+                // rebuilt manifest immediately so subsequent passes see it.
+                if (!File.Exists(NuGetInstallManifest.GetPath(NuGetConfig.InstallPath)))
+                {
+                    var rebuilt = NuGetInstallManifest.TryRebuildFromDisk(NuGetConfig.InstallPath);
+                    if (rebuilt.Packages.Count > 0)
+                    {
+                        Debug.Log($"{Tag} Manifest missing — rebuilt {rebuilt.Packages.Count} entries from on-disk filenames.");
+                        NuGetInstallManifest.Save(NuGetConfig.InstallPath, rebuilt);
+                    }
+                }
+
+                // Install configured packages. Install() populates InstalledThisSession with the
+                // full resolved closure (direct + transitive) by always reading the dep graph,
+                // including for packages already on disk from a previous session.
+                foreach (var package in NuGetConfig.Packages)
+                    anyChanged |= NuGetPackageInstaller.Install(package);
+
+                // Invalidate assembly cache only after packages may have changed,
+                // so RemoveUnnecessaryPackages sees the current state.
+                if (anyChanged)
+                    UnityAssemblyResolver.InvalidateCache();
+
+                // Remove stale-version manifest entries for anything in the closure
+                // and packages whose DLLs are now all provided by Unity.
+                var anyRemoved = NuGetPackageInstaller.RemoveUnnecessaryPackages(
+                    NuGetPackageInstaller.InstalledThisSession);
+                anyChanged |= anyRemoved;
+
+                if (anyChanged)
+                    Debug.Log($"{Tag} Package restore complete. Changes applied (installed and/or removed packages).");
+                else
+                    Debug.Log($"{Tag} All packages up to date.");
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"{Tag} Package restore failed: {ex.Message}\n{ex.StackTrace}");
+            }
+
+            return anyChanged;
+        }
+
+        /// <summary>
+        /// Quick check: are all configured packages already installed at their configured version,
+        /// with no stale-version entries of configured packages present in the manifest, AND is the
+        /// full transitive closure present?
+        /// Used to skip the full restore when everything is up to date. Returning false here forces
+        /// the full Restore() path, which runs migration + reconciliation.
+        /// </summary>
+        public static bool AllPackagesInstalled()
+        {
+            if (!Directory.Exists(NuGetConfig.InstallPath))
+                return false;
+
+            // Legacy per-package directories on disk → migration is pending → force a full restore.
+            // Cheap enough on the steady-state path because there are no legacy directories left
+            // after the first migration run.
+            foreach (var dir in Directory.GetDirectories(NuGetConfig.InstallPath))
+            {
+                var dirName = Path.GetFileName(dir);
+                if (NuGetPackageInstaller.ExtractPackageIdFromDirName(dirName) != null)
+                    return false;
+            }
+
+            // Versioned-filename flat DLL on disk → migration is pending → force restore.
+            foreach (var dllPath in Directory.GetFiles(NuGetConfig.InstallPath, "*.dll", SearchOption.TopDirectoryOnly))
+            {
+                if (NuGetInstallManifest.TryParseInstalledDllName(Path.GetFileName(dllPath), out _, out _))
+                    return false;
+            }
+
+            // Manifest is the source of truth for the flat layout. If it's missing we need a full
+            // restore — Restore() will rebuild it from on-disk filenames as the first step, then
+            // the closure-completeness check below runs against the rebuilt entries.
+            if (!File.Exists(NuGetInstallManifest.GetPath(NuGetConfig.InstallPath)))
+                return false;
+
+            var manifest = NuGetInstallManifest.Load(NuGetConfig.InstallPath);
+
+            var skipSet = new HashSet<string>(NuGetConfig.SkipPackages, StringComparer.OrdinalIgnoreCase);
+
+            // No skip-listed package may sit in the manifest.
+            foreach (var packageId in manifest.Packages.Keys)
+            {
+                if (skipSet.Contains(packageId))
+                    return false;
+            }
+
+            // Every configured package must be installed at the configured version, UNLESS the
+            // package is a development-only dependency (analyzers, source generators, build
+            // tooling). The installer intentionally leaves an empty-Dlls manifest entry for those.
+            foreach (var package in NuGetConfig.Packages)
+            {
+                if (IsCachedDevelopmentDependency(package))
+                {
+                    // Dev-deps are still tracked in the manifest with an empty DLL list — that
+                    // marker tells AllPackagesInstalled() to skip the on-disk DLL check for them.
+                    if (!manifest.Packages.TryGetValue(package.Id, out var devEntry))
+                        return false;
+                    if (!string.Equals(devEntry.Version, package.Version, StringComparison.OrdinalIgnoreCase))
+                        return false;
+                    continue;
+                }
+
+                if (!manifest.Packages.TryGetValue(package.Id, out var entry))
+                    return false;
+                if (!string.Equals(entry.Version, package.Version, StringComparison.OrdinalIgnoreCase))
+                    return false;
+
+                // Versioned-filename manifest entry → pre-unversioned resolver → force restore.
+                foreach (var dll in entry.Dlls)
+                {
+                    if (!File.Exists(Path.Combine(NuGetConfig.InstallPath, dll)))
+                        return false;
+                    if (NuGetInstallManifest.TryParseInstalledDllName(dll, out _, out _))
+                        return false;
+                }
+            }
+
+            // Walk the transitive closure from each configured top-level package via cached
+            // .nuspec files and verify every declared dep has a manifest entry. Catches the
+            // case where a transitive-dep DLL was deleted externally or a prior restore
+            // failed mid-install; without this we'd incorrectly return true and skip the
+            // fix-up pass in Restore().
+            var installedPackageIds = new HashSet<string>(manifest.Packages.Keys, StringComparer.OrdinalIgnoreCase);
+            var visited = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+            foreach (var package in NuGetConfig.Packages)
+            {
+                if (!HasTransitiveClosure(package, visited, installedPackageIds, skipSet))
+                    return false;
+            }
+
+            return true;
+        }
+
+        /// <summary>
+        /// Recursively verifies that <paramref name="package"/> and every package reachable
+        /// through its cached .nuspec dependency list has a manifest entry (any version —
+        /// the resolved version may differ from the declared one due to highest-version-wins,
+        /// but the ID must be present).
+        /// </summary>
+        static bool HasTransitiveClosure(
+            NuGetPackage package,
+            HashSet<string> visited,
+            HashSet<string> installedPackageIds,
+            HashSet<string> skipSet)
+        {
+            if (!visited.Add(package.Id))
+                return true;
+
+            // Skip-listed packages are expected to be absent.
+            if (skipSet.Contains(package.Id))
+                return true;
+
+            var cachedPath = NuGetCache.IsCached(package)
+                ? NuGetCache.GetCachedPath(package)
+                : null;
+
+            // Development-only dependencies (analyzers, source generators, build tooling)
+            // legitimately have an empty DLL list in the manifest.
+            if (cachedPath != null && NuGetExtractor.IsDevelopmentDependency(cachedPath))
+                return true;
+
+            if (!installedPackageIds.Contains(package.Id))
+                return false;
+
+            // If this specific version's .nupkg isn't cached, the package may have been
+            // superseded by a higher version from another chain (which caused Install() to
+            // early-return without downloading this version). The manifest check above
+            // already confirmed the ID is present, so stop recursing here.
+            if (cachedPath == null)
+                return true;
+
+            List<NuGetPackage> deps;
+            try
+            {
+                deps = NuGetExtractor.GetDependencies(cachedPath);
+            }
+            catch
+            {
+                // Corrupted cache — let Restore() re-download and re-validate.
+                return false;
+            }
+
+            foreach (var dep in deps)
+            {
+                if (!HasTransitiveClosure(dep, visited, installedPackageIds, skipSet))
+                    return false;
+            }
+            return true;
+        }
+
+        /// <summary>
+        /// Returns true when <paramref name="package"/>'s .nupkg is on disk in the NuGet cache
+        /// and its .nuspec declares <c>&lt;developmentDependency&gt;true&lt;/developmentDependency&gt;</c>.
+        /// </summary>
+        static bool IsCachedDevelopmentDependency(NuGetPackage package)
+        {
+            if (!NuGetCache.IsCached(package))
+                return false;
+
+            return NuGetExtractor.IsDevelopmentDependency(NuGetCache.GetCachedPath(package));
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/DependencyResolver/NuGetPackageRestorer.cs.meta

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

package/vendor/plugin/com.atelierai.unity.copilot/Editor/DependencyResolver/NuGetPluginConfigurator.cs

@@ -0,0 +1,241 @@
+/*
++------------------------------------------------------------------+
+|  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 UnityEditor;
+using UnityEngine;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.DependencyResolver
+{
+    /// <summary>
+    /// Configures PluginImporter settings for NuGet DLLs.
+    ///
+    /// Handles four cases:
+    ///   1. Unity provides the DLL + we need it in builds → include in builds, exclude from editor
+    ///   2. Unity provides the DLL + editor-only → disable entirely
+    ///   3. We provide the DLL + we need it in builds → include everywhere
+    ///   4. We provide the DLL + editor-only → editor only
+    ///
+    /// Case 1 is critical: assemblies like System.Diagnostics.DiagnosticSource are
+    /// available in the Unity Editor but NOT included in player builds automatically.
+    /// Our NuGet copy must be included in builds while excluded from editor to avoid duplicates.
+    ///
+    /// Since #733: DLLs sit FLAT under <see cref="NuGetConfig.InstallPath"/> with the
+    /// versioned filename pattern <c>{stem}.{packageVersion}.dll</c>. The package → DLL
+    /// owner mapping comes from <see cref="NuGetInstallManifest"/> (we can't infer the
+    /// package ID from the on-disk path anymore — every DLL sits in the same folder).
+    /// </summary>
+    static class NuGetPluginConfigurator
+    {
+        const string Tag = NuGetConfig.LogTag;
+
+        /// <summary>
+        /// Configures PluginImporter for every DLL recorded in the NuGet install manifest.
+        /// Called after packages are installed/restored.
+        /// </summary>
+        public static void ConfigureAll()
+        {
+            if (!Directory.Exists(NuGetConfig.InstallPath))
+                return;
+
+            var manifest = NuGetInstallManifest.Load(NuGetConfig.InstallPath);
+
+            // Batch importer changes so Unity performs a single reimport pass at the end
+            // instead of one reimport per DLL (which was dominating editor startup time
+            // on projects with many NuGet packages).
+            AssetDatabase.StartAssetEditing();
+            try
+            {
+                foreach (var (packageId, entry) in manifest.Packages)
+                {
+                    var includeInBuild = ShouldIncludeInBuild(packageId);
+                    foreach (var dll in entry.Dlls)
+                    {
+                        var dllPath = Path.Combine(NuGetConfig.InstallPath, dll);
+                        if (!File.Exists(dllPath))
+                            continue;
+
+                        // Convert to Unity asset path (forward slashes, relative to project)
+                        var assetPath = dllPath.Replace('\\', '/');
+                        ConfigureDll(assetPath, includeInBuild);
+                    }
+                }
+            }
+            finally
+            {
+                AssetDatabase.StopAssetEditing();
+            }
+        }
+
+        /// <summary>
+        /// Configures a single DLL's PluginImporter settings.
+        /// </summary>
+        public static void ConfigureDll(string assetPath, bool includeInBuild)
+        {
+            var importer = AssetImporter.GetAtPath(assetPath) as PluginImporter;
+            if (importer == null)
+                return;
+
+            // The DLL filename carries the package version as a tail segment
+            // (e.g. "System.Memory.10.0.3.dll"). Strip it so the assembly-
+            // resolver lookup matches the assembly's manifest name, not the
+            // on-disk filename.
+            var fileName = Path.GetFileName(assetPath);
+            var assemblyName = NuGetInstallManifest.TryParseInstalledDllName(fileName, out var stem, out _) && stem != null
+                ? stem
+                : Path.GetFileNameWithoutExtension(assetPath);
+
+            var unityProvidesIt = UnityAssemblyResolver.IsAlreadyImported(assemblyName);
+
+            bool anyPlatform;
+            bool excludeEditor;
+            bool editorOnly;
+
+            if (unityProvidesIt && includeInBuild)
+            {
+                // Unity provides this DLL in the editor, but builds need our copy.
+                anyPlatform = true;
+                excludeEditor = true;
+                editorOnly = false;
+            }
+            else if (unityProvidesIt)
+            {
+                // Unity provides it and we don't need it in builds — disable entirely.
+                anyPlatform = false;
+                excludeEditor = false;
+                editorOnly = false;
+            }
+            else if (includeInBuild)
+            {
+                // Runtime DLL not provided by Unity: include everywhere.
+                anyPlatform = true;
+                excludeEditor = false;
+                editorOnly = false;
+            }
+            else
+            {
+                // Editor-only DLL not provided by Unity.
+                anyPlatform = false;
+                excludeEditor = false;
+                editorOnly = true;
+            }
+
+            // Check if settings need to change
+            var currentAnyPlatform = importer.GetCompatibleWithAnyPlatform();
+            var currentEditor = importer.GetCompatibleWithEditor();
+            var currentExcludeEditor = importer.GetExcludeEditorFromAnyPlatform();
+
+            // When Any Platform is on, the Editor flag must also track !excludeEditor —
+            // otherwise a stale Editor=0 left over from Unity's initial import silently
+            // survives (this was the cause of "Unloading broken assembly" on startup).
+            var expectedEditor = anyPlatform ? !excludeEditor : editorOnly;
+            var needsChange = currentAnyPlatform != anyPlatform
+                           || currentExcludeEditor != excludeEditor
+                           || currentEditor != expectedEditor;
+
+            if (!needsChange)
+                return;
+
+            if (anyPlatform)
+            {
+                importer.SetCompatibleWithAnyPlatform(true);
+                importer.SetExcludeEditorFromAnyPlatform(excludeEditor);
+                // Explicitly sync the individual Editor platform flag. Unity's initial import
+                // sometimes leaves Editor at enabled=0 even when Any Platform is on without
+                // Exclude Editor; without this call, the stale 0 persists in the .meta and
+                // Editor-side loading fails (e.g., "Unloading broken assembly ..." for DLLs
+                // whose transitive deps are also editor-disabled).
+                importer.SetCompatibleWithEditor(!excludeEditor);
+            }
+            else
+            {
+                importer.SetCompatibleWithAnyPlatform(false);
+                importer.SetCompatibleWithEditor(editorOnly);
+            }
+
+            importer.SaveAndReimport();
+            Debug.Log($"{Tag} Configured '{assemblyName}': anyPlatform={anyPlatform}, excludeEditor={excludeEditor}, editorOnly={editorOnly}");
+        }
+
+        /// <summary>
+        /// Sets the file's <see cref="PluginImporter"/> compatibility to "no
+        /// platforms" so Unity unloads the DLL on the next domain reload,
+        /// freeing the OS file handle. Used by the legacy-folder migration
+        /// and the stale-flat sweep to recover from the case where Unity has
+        /// the assembly loaded into the editor AppDomain and the file is
+        /// therefore locked. Safe to call on non-DLL files or paths Unity
+        /// hasn't imported (no-op).
+        /// </summary>
+        public static void DisableImporter(string filePath)
+        {
+            if (!filePath.EndsWith(".dll", System.StringComparison.OrdinalIgnoreCase))
+                return;
+
+            // Asset paths use forward slashes and are project-relative;
+            // Windows Path APIs may have inserted '\' so normalise here.
+            var assetPath = filePath.Replace('\\', '/');
+
+            try
+            {
+                if (!(AssetImporter.GetAtPath(assetPath) is PluginImporter importer))
+                    return;
+
+                importer.SetCompatibleWithAnyPlatform(false);
+                importer.SetCompatibleWithEditor(false);
+                importer.SaveAndReimport();
+
+                Debug.Log($"{Tag} Disabled PluginImporter for locked '{assetPath}'; deletion will be retried after the next domain reload.");
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning($"{Tag} Could not disable PluginImporter for '{assetPath}': {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Best-effort <see cref="File.Delete"/> that swallows missing-file
+        /// races and logs a warning on any other failure. Shared between the
+        /// migration and per-package install paths so the two surfaces don't
+        /// drift on what counts as "best effort".
+        /// </summary>
+        internal static void TryDeleteFile(string path)
+        {
+            if (!File.Exists(path))
+                return;
+            try
+            {
+                File.Delete(path);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning($"{Tag} Failed to delete '{path}': {ex.Message}");
+            }
+        }
+
+        /// <summary>
+        /// Determines if a DLL should be included in game builds based on its
+        /// owning package ID. Configured packages use their IncludeInBuild flag.
+        /// Transitive dependencies default to included (runtime packages depend on them).
+        /// </summary>
+        static bool ShouldIncludeInBuild(string packageId)
+        {
+            foreach (var package in NuGetConfig.Packages)
+            {
+                if (string.Equals(packageId, package.Id, System.StringComparison.OrdinalIgnoreCase))
+                    return package.IncludeInBuild;
+            }
+
+            // Transitive dependency — include in builds by default.
+            return true;
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/DependencyResolver/NuGetPluginConfigurator.cs.meta

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

package/vendor/plugin/com.atelierai.unity.copilot/Editor/DependencyResolver/NuGetResolverMenu.cs

@@ -0,0 +1,60 @@
+/*
++------------------------------------------------------------------+
+|  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 UnityEditor;
+using UnityEngine;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.DependencyResolver
+{
+    /// <summary>
+    /// Adds a Unity Editor menu item that forces a full NuGet DLL re-resolve on demand.
+    /// The automatic resolver in <see cref="NuGetDependencyResolver"/> only runs the full
+    /// restore path when <see cref="NuGetPackageRestorer.AllPackagesInstalled"/> reports
+    /// something is missing. This menu item bypasses that quick-check so users can recover
+    /// from an inconsistent on-disk DLL state without manually deleting Assets/Plugins/NuGet.
+    /// </summary>
+    static class NuGetResolverMenu
+    {
+        const string Tag = NuGetConfig.LogTag;
+        const string MenuPath = "Tools/AI Game Developer/Dependencies/Force Resolve NuGet DLLs";
+
+        [MenuItem(MenuPath, priority = 1050)]
+        public static void ForceResolve()
+        {
+            Debug.Log($"{Tag} Force resolve requested — running full restore...");
+
+            // Force a clean recompile so the AssetDatabase.Refresh() at the
+            // bottom runs against fresh assemblies, not the stale AppDomain.
+            RecompileGate.Reset();
+
+            try
+            {
+                var changed = NuGetPackageRestorer.Restore();
+                NuGetPluginConfigurator.ConfigureAll();
+
+                if (changed)
+                {
+                    Debug.Log($"{Tag} Force resolve complete. Refreshing AssetDatabase...");
+                    AssetDatabase.Refresh();
+                }
+                else
+                {
+                    Debug.Log($"{Tag} Force resolve complete. No changes needed.");
+                }
+            }
+            catch (Exception ex)
+            {
+                Debug.LogError($"{Tag} Force resolve failed: {ex}");
+            }
+        }
+    }
+}

package/vendor/plugin/com.atelierai.unity.copilot/Editor/DependencyResolver/NuGetResolverMenu.cs.meta

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