@mflrevan/ucp 0.5.0 → 0.5.2

package/bridge/com.ucp.bridge/Editor/Controllers/AssetImportSupport.cs

@@ -80,6 +80,47 @@ namespace UCP.Bridge
             return CreateReimportResult(requestedPath, assetPath, true, false, null);
         }
 
+        public static Dictionary<string, object> ReimportRecursive(string requestedPath, bool forceSynchronous = true)
+        {
+            var assetPath = GetPrimaryAssetPath(requestedPath);
+            if (string.IsNullOrEmpty(assetPath))
+                throw new ArgumentException("Missing 'path' parameter");
+            if (!IsProjectAssetPath(assetPath))
+                throw new ArgumentException($"Path is not under Assets/ or Packages/: {requestedPath}");
+
+            if (!AssetDatabase.IsValidFolder(assetPath))
+                return Reimport(requestedPath, forceSynchronous);
+
+            var options = ImportAssetOptions.ForceUpdate;
+            if (forceSynchronous)
+                options |= ImportAssetOptions.ForceSynchronousImport;
+
+            var guidResults = AssetDatabase.FindAssets(string.Empty, new[] { assetPath });
+            var importedPaths = new HashSet<string>(StringComparer.OrdinalIgnoreCase);
+
+            foreach (var guid in guidResults)
+            {
+                var childPath = AssetDatabase.GUIDToAssetPath(guid);
+                if (string.IsNullOrEmpty(childPath) || AssetDatabase.IsValidFolder(childPath))
+                    continue;
+
+                AssetDatabase.ImportAsset(childPath, options);
+                importedPaths.Add(childPath);
+                RecordReimport(childPath);
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["requestedPath"] = requestedPath,
+                ["assetPath"] = assetPath,
+                ["recursive"] = true,
+                ["requested"] = importedPaths.Count,
+                ["reimported"] = importedPaths.Count,
+                ["skipped"] = 0,
+                ["paths"] = new List<object>(importedPaths)
+            };
+        }
+
         public static Dictionary<string, object> SaveImporterSettings(string requestedPath, AssetImporter importer, bool noReimport)
         {
             if (importer == null)

package/bridge/com.ucp.bridge/Editor/Controllers/CompilationController.cs

@@ -1,5 +1,9 @@
 using UnityEditor;
 using UnityEditor.Compilation;
+using System;
+using System.Collections.Generic;
+using System.IO;
+using System.Text.RegularExpressions;
 
 namespace UCP.Bridge
 {
@@ -9,12 +13,15 @@ namespace UCP.Bridge
         {
             router.Register("compile", HandleCompile);
             router.Register("refresh-assets", HandleRefresh);
+            router.Register("script/doctor", HandleScriptDoctor);
         }
 
         private static object HandleCompile(string paramsJson)
         {
+            AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
             CompilationPipeline.RequestScriptCompilation();
-            return new { status = "ok", message = "Compilation requested" };
+            TrySyncSolution();
+            return new { status = "ok", message = "Asset database refreshed and compilation requested" };
         }
 
         private static object HandleRefresh(string paramsJson)
@@ -22,5 +29,85 @@ namespace UCP.Bridge
             AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
             return new { status = "ok", message = "Asset database refreshed" };
         }
+
+        private static object HandleScriptDoctor(string paramsJson)
+        {
+            var p = MiniJson.Deserialize(paramsJson) as Dictionary<string, object>;
+            var fix = p != null && p.TryGetValue("fix", out var fixObj) && fixObj != null && Convert.ToBoolean(fixObj);
+            var projectRoot = Directory.GetParent(UnityEngine.Application.dataPath).FullName;
+            var projects = new List<object>();
+            var staleProjectCount = 0;
+            var missingFileCount = 0;
+            var deletedProjectCount = 0;
+
+            foreach (var csproj in Directory.GetFiles(projectRoot, "*.csproj", SearchOption.TopDirectoryOnly))
+            {
+                var missing = FindMissingCompileItems(projectRoot, csproj);
+                if (missing.Count > 0)
+                {
+                    staleProjectCount++;
+                    missingFileCount += missing.Count;
+                    if (fix)
+                    {
+                        File.Delete(csproj);
+                        deletedProjectCount++;
+                    }
+                }
+
+                projects.Add(new Dictionary<string, object>
+                {
+                    ["path"] = csproj,
+                    ["missingCompileItems"] = missing.ConvertAll<object>(item => item),
+                    ["stale"] = missing.Count > 0
+                });
+            }
+
+            if (fix)
+            {
+                AssetDatabase.Refresh(ImportAssetOptions.ForceSynchronousImport);
+                TrySyncSolution();
+            }
+
+            return new Dictionary<string, object>
+            {
+                ["status"] = "ok",
+                ["projectRoot"] = projectRoot,
+                ["projectCount"] = projects.Count,
+                ["staleProjectCount"] = staleProjectCount,
+                ["missingFileCount"] = missingFileCount,
+                ["deletedProjectCount"] = deletedProjectCount,
+                ["fixed"] = fix,
+                ["projects"] = projects
+            };
+        }
+
+        private static List<string> FindMissingCompileItems(string projectRoot, string csproj)
+        {
+            var missing = new List<string>();
+            var content = File.ReadAllText(csproj);
+            foreach (Match match in Regex.Matches(content, "<Compile Include=\"([^\"]+\\.cs)\""))
+            {
+                var include = match.Groups[1].Value.Replace('\\', Path.DirectorySeparatorChar);
+                var fullPath = Path.GetFullPath(Path.Combine(projectRoot, include));
+                if (!File.Exists(fullPath))
+                    missing.Add(include.Replace('\\', '/'));
+            }
+
+            return missing;
+        }
+
+        private static void TrySyncSolution()
+        {
+            try
+            {
+                var syncVs = typeof(Editor).Assembly.GetType("UnityEditor.SyncVS");
+                var method = syncVs?.GetMethod("SyncSolution", System.Reflection.BindingFlags.Static | System.Reflection.BindingFlags.Public | System.Reflection.BindingFlags.NonPublic, null, Type.EmptyTypes, null);
+                method?.Invoke(null, null);
+            }
+            catch
+            {
+                // Best-effort only; Unity may regenerate solution files asynchronously.
+            }
+        }
     }
 }

package/bridge/com.ucp.bridge/Editor/Controllers/ImporterController.cs

@@ -18,7 +18,10 @@ namespace UCP.Bridge
         {
             var parameters = ParseParameters(paramsJson);
             var requestedPath = RequirePath(parameters);
-            return AssetImportSupport.Reimport(requestedPath);
+            var recursive = TryGetOptionalBool(parameters, "recursive");
+            return recursive
+                ? AssetImportSupport.ReimportRecursive(requestedPath)
+                : AssetImportSupport.Reimport(requestedPath);
         }
 
         private static object HandleRead(string paramsJson)