@atelierai/uco 1.0.0

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

@@ -0,0 +1,546 @@
+/*
++------------------------------------------------------------------+
+|  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 System.Text;
+using System.Text.RegularExpressions;
+using UnityEngine;
+
+namespace com.AtelierAI.Unity.Copilot.Editor.DependencyResolver
+{
+    /// <summary>
+    /// On-disk manifest for the flat-layout NuGet install path. Replaces the
+    /// directory-name-as-source-of-truth model that the per-package
+    /// <c>{Id}.{Version}/</c> layout used pre-#733.
+    ///
+    /// File location: <c>{installPath}/.nuget-installed.json</c>.
+    /// Schema:
+    /// <code>
+    /// {
+    ///   "packages": {
+    ///     "Microsoft.AspNetCore.Http.Connections.Client": {
+    ///       "version": "8.0.15",
+    ///       "dlls": ["Microsoft.AspNetCore.Http.Connections.Client.8.0.15.dll"]
+    ///     },
+    ///     "Microsoft.Bcl.Memory": {
+    ///       "version": "10.0.3",
+    ///       "dlls": [
+    ///         "System.Memory.10.0.3.dll",
+    ///         "System.Buffers.10.0.3.dll",
+    ///         "System.Runtime.CompilerServices.Unsafe.10.0.3.dll"
+    ///       ]
+    ///     }
+    ///   }
+    /// }
+    /// </code>
+    ///
+    /// The manifest is the primary source of truth for "which DLL belongs to
+    /// which package at which version". Filename parsing
+    /// (<see cref="TryParseInstalledDllName"/>) is the disaster-recovery
+    /// fallback — even if the manifest is deleted, the on-disk filenames
+    /// carry enough metadata for <see cref="TryRebuildFromDisk"/> to
+    /// reconstruct one.
+    /// </summary>
+    static class NuGetInstallManifest
+    {
+        const string Tag = NuGetConfig.LogTag;
+        public const string FileName = ".nuget-installed.json";
+
+        /// <summary>
+        /// Returns the absolute path to the manifest file under the supplied
+        /// install path.
+        /// </summary>
+        public static string GetPath(string installPath) =>
+            Path.Combine(installPath, FileName);
+
+        /// <summary>
+        /// Loads the manifest from disk. Returns an empty manifest when the file
+        /// is missing or unparseable; the caller is responsible for treating
+        /// that as "needs full restore".
+        /// </summary>
+        public static InstallManifest Load(string installPath)
+        {
+            var path = GetPath(installPath);
+            if (!File.Exists(path))
+                return new InstallManifest();
+
+            try
+            {
+                var json = File.ReadAllText(path);
+                return ManifestJsonParser.Parse(json);
+            }
+            catch (Exception ex)
+            {
+                Debug.LogWarning($"{Tag} Manifest at '{path}' could not be parsed ({ex.Message}); treating as empty and rebuilding.");
+                return new InstallManifest();
+            }
+        }
+
+        /// <summary>
+        /// Writes the manifest to disk atomically. Creates the install directory
+        /// if it does not exist. Writes to a sibling <c>.tmp</c> file first and
+        /// then moves it into place, so a crash or power loss mid-write cannot
+        /// leave a truncated/empty <c>.nuget-installed.json</c> behind.
+        /// </summary>
+        public static void Save(string installPath, InstallManifest manifest)
+        {
+            if (!Directory.Exists(installPath))
+                Directory.CreateDirectory(installPath);
+
+            var path = GetPath(installPath);
+            var tempPath = path + ".tmp";
+            var json = ManifestJsonParser.Serialize(manifest);
+
+            File.WriteAllText(tempPath, json);
+            try
+            {
+                // Atomic rename: delete the destination first so File.Move (the
+                // .NET Standard 2.0-compatible overload that Unity's bundled
+                // Mono ships) does not throw IOException("destination exists").
+                // The delete-then-move sequence is not strictly atomic on
+                // Windows, but it removes the truncated-file failure mode the
+                // bug report calls out (a crash mid-WriteAllText would leave an
+                // empty/partial .nuget-installed.json; the staging-file
+                // approach guarantees the destination is either the previous
+                // valid file or the freshly serialized one — never partial).
+                if (File.Exists(path))
+                    File.Delete(path);
+                File.Move(tempPath, path);
+            }
+            catch
+            {
+                // Best-effort cleanup of the staging file if the rename fails.
+                try { if (File.Exists(tempPath)) File.Delete(tempPath); }
+                catch { /* ignore cleanup error — surface the original failure */ }
+                throw;
+            }
+        }
+
+        /// <summary>
+        /// Rebuilds an in-memory manifest by scanning the install directory
+        /// for the legacy versioned DLL filename shape
+        /// <c>{stem}.{version}.dll</c>. Unversioned canonical filenames are
+        /// skipped (we can't recover their version from disk; if the manifest
+        /// is missing, the next <c>Restore()</c> re-extracts every package
+        /// from .nupkg cache and rebuilds the manifest authoritatively).
+        ///
+        /// Used when <c>.nuget-installed.json</c> is missing, corrupt, or
+        /// out-of-sync with disk (the disaster-recovery path). The caller is
+        /// responsible for persisting the rebuilt manifest via <see cref="Save"/>.
+        ///
+        /// <para>
+        /// Filename-only rebuild cannot recover the package ID for multi-DLL
+        /// packages where each DLL stem differs from the package ID (e.g.
+        /// <c>Microsoft.Bcl.Memory</c> ships <c>System.Memory.10.0.3.dll</c>).
+        /// For such DLLs the rebuild treats the DLL stem itself as the package
+        /// ID; the next full restore reconciles the synthetic IDs against the
+        /// dependency closure (the closure is the authoritative source). This
+        /// is enough to satisfy the steady-state "manifest deleted, no
+        /// re-extraction needed" disaster-recovery acceptance criterion for
+        /// the pre-unversioned-filename layouts that still ship versioned
+        /// filenames on disk.
+        /// </para>
+        /// </summary>
+        public static InstallManifest TryRebuildFromDisk(string installPath)
+        {
+            var manifest = new InstallManifest();
+            if (!Directory.Exists(installPath))
+                return manifest;
+
+            foreach (var dllPath in Directory.GetFiles(installPath, "*.dll", SearchOption.TopDirectoryOnly))
+            {
+                var fileName = Path.GetFileName(dllPath);
+                if (!TryParseInstalledDllName(fileName, out var stem, out var version) || stem == null || version == null)
+                    continue;
+
+                if (!manifest.Packages.TryGetValue(stem, out var entry))
+                {
+                    entry = new InstalledPackage(version);
+                    manifest.Packages[stem] = entry;
+                }
+                else if (!string.Equals(entry.Version, version, StringComparison.OrdinalIgnoreCase))
+                {
+                    // Multiple versions of the same DLL stem on disk shouldn't
+                    // happen in a healthy install. If it does, latest-wins for
+                    // the rebuild and the next Restore() pass will reconcile
+                    // and clean up the loser.
+                    entry = new InstalledPackage(version);
+                    manifest.Packages[stem] = entry;
+                }
+                if (!entry.Dlls.Contains(fileName, StringComparer.OrdinalIgnoreCase))
+                    entry.Dlls.Add(fileName);
+            }
+
+            return manifest;
+        }
+
+        /// <summary>
+        /// Splits a versioned install filename of the form
+        /// <c>{stem}.{version}.dll</c> back into its stem and version parts.
+        /// Returns false for canonical unversioned names (e.g. <c>System.Memory.dll</c>)
+        /// or names whose version-tail does not parse as a System.Version —
+        /// useful as a "is this a leftover from the pre-unversioned-filename
+        /// layout?" predicate.
+        ///
+        /// The version segment is matched as <c>\d+(\.\d+){1,3}</c> at the
+        /// tail before <c>.dll</c>. The match is greedy on the tail so that
+        /// <c>System.Memory.10.0.3.dll</c> splits as stem=<c>System.Memory</c>
+        /// + version=<c>10.0.3</c>, not stem=<c>System.Memory.10.0</c> +
+        /// version=<c>3</c>.
+        /// </summary>
+        public static bool TryParseInstalledDllName(string fileName, out string? stem, out string? version)
+        {
+            stem = null;
+            version = null;
+
+            if (string.IsNullOrEmpty(fileName))
+                return false;
+            if (!fileName.EndsWith(".dll", StringComparison.OrdinalIgnoreCase))
+                return false;
+
+            var noExt = fileName.Substring(0, fileName.Length - 4);
+            var match = VersionTailPattern.Match(noExt);
+            if (!match.Success)
+                return false;
+
+            var versionString = match.Groups[1].Value;
+            if (!System.Version.TryParse(versionString, out _))
+                return false;
+
+            var stemEnd = match.Index;
+            if (stemEnd <= 0)
+                return false;
+
+            stem = noExt.Substring(0, stemEnd);
+            version = versionString;
+            return true;
+        }
+
+        // Anchor a 1-4 segment numeric tail (each segment 1-9 digits — System.Version's
+        // ceiling) to the end of the stem. Used to detect / peel the version off
+        // filenames left over from the pre-unversioned-filename layout.
+        static readonly Regex VersionTailPattern = new(@"\.(\d+(?:\.\d+){1,3})$", RegexOptions.Compiled);
+    }
+
+    /// <summary>
+    /// In-memory representation of <see cref="NuGetInstallManifest"/>'s on-disk schema.
+    /// </summary>
+    sealed class InstallManifest
+    {
+        /// <summary>
+        /// Map of NuGet package ID → installed entry. Comparison is
+        /// case-insensitive to match the rest of the resolver.
+        /// </summary>
+        public Dictionary<string, InstalledPackage> Packages { get; }
+            = new(StringComparer.OrdinalIgnoreCase);
+
+        public InstallManifest Clone()
+        {
+            var copy = new InstallManifest();
+            foreach (var kv in Packages)
+                copy.Packages[kv.Key] = new InstalledPackage(kv.Value.Version, kv.Value.Dlls);
+            return copy;
+        }
+    }
+
+    /// <summary>
+    /// One entry in <see cref="InstallManifest.Packages"/>.
+    /// </summary>
+    sealed class InstalledPackage
+    {
+        /// <summary>The package version this entry was installed at.</summary>
+        public string Version { get; set; }
+
+        /// <summary>
+        /// DLL filenames (relative to the install path) the package owns at this
+        /// version. Each filename is of the form <c>{stem}.{version}.dll</c>.
+        /// </summary>
+        public List<string> Dlls { get; }
+
+        public InstalledPackage(string version)
+        {
+            Version = version;
+            Dlls = new List<string>();
+        }
+
+        public InstalledPackage(string version, IEnumerable<string> dlls)
+        {
+            Version = version;
+            Dlls = new List<string>(dlls);
+        }
+    }
+
+    /// <summary>
+    /// Hand-rolled JSON read/write for <see cref="InstallManifest"/>. Avoids a
+    /// dependency on <c>System.Text.Json</c> / <c>Newtonsoft.Json</c> so the
+    /// DependencyResolver assembly stays the only one that compiles before any
+    /// NuGet package is on disk (the same invariant <c>NuGetDependencyResolver</c>
+    /// is built against).
+    /// </summary>
+    static class ManifestJsonParser
+    {
+        public static string Serialize(InstallManifest manifest)
+        {
+            var sb = new StringBuilder();
+            sb.AppendLine("{");
+            sb.AppendLine("  \"packages\": {");
+
+            // Stable ordering — keeps the file diff-friendly across runs.
+            var ordered = manifest.Packages
+                .OrderBy(kv => kv.Key, StringComparer.OrdinalIgnoreCase)
+                .ToList();
+            for (var i = 0; i < ordered.Count; i++)
+            {
+                var (id, entry) = (ordered[i].Key, ordered[i].Value);
+                sb.Append("    \"").Append(JsonEscape(id)).Append("\": {");
+                sb.AppendLine();
+                sb.Append("      \"version\": \"").Append(JsonEscape(entry.Version)).Append("\",");
+                sb.AppendLine();
+                sb.Append("      \"dlls\": [");
+                if (entry.Dlls.Count == 0)
+                {
+                    sb.Append("]");
+                }
+                else
+                {
+                    sb.AppendLine();
+                    for (var j = 0; j < entry.Dlls.Count; j++)
+                    {
+                        sb.Append("        \"").Append(JsonEscape(entry.Dlls[j])).Append("\"");
+                        if (j < entry.Dlls.Count - 1)
+                            sb.Append(",");
+                        sb.AppendLine();
+                    }
+                    sb.Append("      ]");
+                }
+                sb.AppendLine();
+                sb.Append("    }");
+                if (i < ordered.Count - 1)
+                    sb.Append(",");
+                sb.AppendLine();
+            }
+
+            sb.AppendLine("  }");
+            sb.Append("}");
+            return sb.ToString();
+        }
+
+        public static InstallManifest Parse(string json)
+        {
+            var manifest = new InstallManifest();
+            var parser = new MicroJsonParser(json);
+            var root = parser.ParseValue() as Dictionary<string, object?>;
+            if (root == null)
+                return manifest;
+
+            if (!root.TryGetValue("packages", out var packagesObj) || packagesObj is not Dictionary<string, object?> packages)
+                return manifest;
+
+            foreach (var (id, valueObj) in packages)
+            {
+                if (valueObj is not Dictionary<string, object?> entryObj)
+                    continue;
+
+                var version = entryObj.TryGetValue("version", out var versionObj) ? versionObj as string : null;
+                if (string.IsNullOrEmpty(version))
+                    continue;
+
+                var entry = new InstalledPackage(version!);
+                if (entryObj.TryGetValue("dlls", out var dllsObj) && dllsObj is List<object?> dlls)
+                {
+                    foreach (var dllObj in dlls)
+                    {
+                        if (dllObj is string dll)
+                            entry.Dlls.Add(dll);
+                    }
+                }
+
+                manifest.Packages[id] = entry;
+            }
+
+            return manifest;
+        }
+
+        static string JsonEscape(string value)
+        {
+            var sb = new StringBuilder(value.Length + 2);
+            foreach (var c in value)
+            {
+                switch (c)
+                {
+                    case '\\': sb.Append("\\\\"); break;
+                    case '"': sb.Append("\\\""); break;
+                    case '\n': sb.Append("\\n"); break;
+                    case '\r': sb.Append("\\r"); break;
+                    case '\t': sb.Append("\\t"); break;
+                    case '\b': sb.Append("\\b"); break;
+                    case '\f': sb.Append("\\f"); break;
+                    default:
+                        if (c < 0x20)
+                            sb.Append("\\u").Append(((int)c).ToString("x4"));
+                        else
+                            sb.Append(c);
+                        break;
+                }
+            }
+            return sb.ToString();
+        }
+
+        /// <summary>
+        /// Minimal JSON parser. Handles objects, arrays, strings, numbers,
+        /// booleans, and null. Sufficient for the manifest schema; not a
+        /// general-purpose parser.
+        /// </summary>
+        sealed class MicroJsonParser
+        {
+            readonly string _src;
+            int _pos;
+
+            public MicroJsonParser(string src) { _src = src; _pos = 0; }
+
+            public object? ParseValue()
+            {
+                SkipWhitespace();
+                if (_pos >= _src.Length)
+                    return null;
+                var c = _src[_pos];
+                return c switch
+                {
+                    '{' => ParseObject(),
+                    '[' => ParseArray(),
+                    '"' => ParseString(),
+                    't' or 'f' => ParseBool(),
+                    'n' => ParseNull(),
+                    _ => ParseNumber(),
+                };
+            }
+
+            Dictionary<string, object?> ParseObject()
+            {
+                var result = new Dictionary<string, object?>(StringComparer.Ordinal);
+                Expect('{');
+                SkipWhitespace();
+                if (Peek() == '}') { _pos++; return result; }
+
+                while (true)
+                {
+                    SkipWhitespace();
+                    var key = ParseString();
+                    SkipWhitespace();
+                    Expect(':');
+                    var value = ParseValue();
+                    result[key] = value;
+                    SkipWhitespace();
+                    if (Peek() == ',') { _pos++; continue; }
+                    if (Peek() == '}') { _pos++; return result; }
+                    throw new FormatException($"Expected ',' or '}}' at {_pos}");
+                }
+            }
+
+            List<object?> ParseArray()
+            {
+                var result = new List<object?>();
+                Expect('[');
+                SkipWhitespace();
+                if (Peek() == ']') { _pos++; return result; }
+
+                while (true)
+                {
+                    var value = ParseValue();
+                    result.Add(value);
+                    SkipWhitespace();
+                    if (Peek() == ',') { _pos++; continue; }
+                    if (Peek() == ']') { _pos++; return result; }
+                    throw new FormatException($"Expected ',' or ']' at {_pos}");
+                }
+            }
+
+            string ParseString()
+            {
+                Expect('"');
+                var sb = new StringBuilder();
+                while (_pos < _src.Length)
+                {
+                    var c = _src[_pos++];
+                    if (c == '"') return sb.ToString();
+                    if (c == '\\')
+                    {
+                        if (_pos >= _src.Length) break;
+                        var esc = _src[_pos++];
+                        switch (esc)
+                        {
+                            case '\\': sb.Append('\\'); break;
+                            case '"': sb.Append('"'); break;
+                            case '/': sb.Append('/'); break;
+                            case 'n': sb.Append('\n'); break;
+                            case 'r': sb.Append('\r'); break;
+                            case 't': sb.Append('\t'); break;
+                            case 'b': sb.Append('\b'); break;
+                            case 'f': sb.Append('\f'); break;
+                            case 'u':
+                                if (_pos + 4 > _src.Length)
+                                    throw new FormatException("Truncated \\u escape");
+                                sb.Append((char)Convert.ToInt32(_src.Substring(_pos, 4), 16));
+                                _pos += 4;
+                                break;
+                            default: sb.Append(esc); break;
+                        }
+                    }
+                    else
+                    {
+                        sb.Append(c);
+                    }
+                }
+                throw new FormatException("Unterminated string");
+            }
+
+            bool ParseBool()
+            {
+                if (_src.Length - _pos >= 4 && _src.Substring(_pos, 4) == "true") { _pos += 4; return true; }
+                if (_src.Length - _pos >= 5 && _src.Substring(_pos, 5) == "false") { _pos += 5; return false; }
+                throw new FormatException($"Expected bool at {_pos}");
+            }
+
+            object? ParseNull()
+            {
+                if (_src.Length - _pos >= 4 && _src.Substring(_pos, 4) == "null") { _pos += 4; return null; }
+                throw new FormatException($"Expected null at {_pos}");
+            }
+
+            double ParseNumber()
+            {
+                var start = _pos;
+                if (Peek() == '-') _pos++;
+                while (_pos < _src.Length && (char.IsDigit(_src[_pos]) || _src[_pos] == '.' || _src[_pos] == 'e' || _src[_pos] == 'E' || _src[_pos] == '+' || _src[_pos] == '-'))
+                    _pos++;
+                return double.Parse(_src.Substring(start, _pos - start), System.Globalization.CultureInfo.InvariantCulture);
+            }
+
+            void Expect(char expected)
+            {
+                if (_pos >= _src.Length || _src[_pos] != expected)
+                    throw new FormatException($"Expected '{expected}' at {_pos}");
+                _pos++;
+            }
+
+            char Peek() => _pos < _src.Length ? _src[_pos] : '\0';
+
+            void SkipWhitespace()
+            {
+                while (_pos < _src.Length && char.IsWhiteSpace(_src[_pos]))
+                    _pos++;
+            }
+        }
+    }
+}

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

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