flockbay 0.10.15 → 0.10.16

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "flockbay",
-  "version": "0.10.15",
+  "version": "0.10.16",
   "description": "Flockbay CLI (local agent + daemon)",
   "author": "Eduardo Orellana",
   "license": "UNLICENSED",

package/tools/unreal-mcp/upstream/MCPGameProject/Plugins/UnrealMCP/Source/UnrealMCP/Private/Commands/UnrealMCPBlueprintCommands.cpp

@@ -18,6 +18,8 @@
 #include "UObject/FieldPath.h"
 #include "EditorAssetLibrary.h"
 #include "AssetRegistry/AssetRegistryModule.h"
+#include "MessageLogModule.h"
+#include "IMessageLogListing.h"
 #include "GameFramework/Actor.h"
 #include "GameFramework/Pawn.h"
 
@@ -47,6 +49,10 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintCommands::HandleCommand(const FString
     {
         return HandleCompileBlueprint(Params);
     }
+    else if (CommandType == TEXT("compile_blueprints_all"))
+    {
+        return HandleCompileBlueprintsAll(Params);
+    }
     else if (CommandType == TEXT("spawn_blueprint_actor"))
     {
         return HandleSpawnBlueprintActor(Params);
@@ -67,17 +73,66 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintCommands::HandleCommand(const FString
     return FUnrealMCPCommonUtils::CreateErrorResponse(FString::Printf(TEXT("Unknown blueprint command: %s"), *CommandType));
 }
 
+static bool IsSafeToCompileBlueprints(FString& OutError)
+{
+    if (!GEditor)
+    {
+        OutError = TEXT("Editor is not available (GEditor is null).");
+        return false;
+    }
+    if (GEditor->PlayWorld)
+    {
+        OutError = TEXT("Cannot compile Blueprints while Play-In-Editor is running. Stop PIE and retry.");
+        return false;
+    }
+    return true;
+}
+
+static FString MessageSeverityToString(EMessageSeverity::Type Severity)
+{
+    switch (Severity)
+    {
+        case EMessageSeverity::CriticalError:
+        case EMessageSeverity::Error:
+            return TEXT("error");
+        case EMessageSeverity::Warning:
+        case EMessageSeverity::PerformanceWarning:
+            return TEXT("warning");
+        case EMessageSeverity::Info:
+            return TEXT("info");
+        default:
+            return TEXT("info");
+    }
+}
+
 TSharedPtr<FJsonObject> FUnrealMCPBlueprintCommands::HandleCreateBlueprint(const TSharedPtr<FJsonObject>& Params)
 {
     // Get required parameters
     FString BlueprintName;
-    if (!Params->TryGetStringField(TEXT("name"), BlueprintName))
+    if (!Params->TryGetStringField(TEXT("name"), BlueprintName) && !Params->TryGetStringField(TEXT("blueprint_name"), BlueprintName))
     {
         return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'name' parameter"));
     }
 
     // Check if blueprint already exists
     FString PackagePath = TEXT("/Game/Blueprints/");
+    Params->TryGetStringField(TEXT("path"), PackagePath);
+    Params->TryGetStringField(TEXT("blueprint_path"), PackagePath);
+    Params->TryGetStringField(TEXT("packagePath"), PackagePath);
+    Params->TryGetStringField(TEXT("package_path"), PackagePath);
+
+    PackagePath = PackagePath.TrimStartAndEnd();
+    if (PackagePath.IsEmpty()) PackagePath = TEXT("/Game/Blueprints/");
+    if (!PackagePath.StartsWith(TEXT("/Game/")))
+    {
+        // Keep it safe + predictable: only allow /Game paths.
+        PackagePath = TEXT("/Game/Blueprints/");
+    }
+    if (!PackagePath.EndsWith(TEXT("/")))
+    {
+        PackagePath += TEXT("/");
+    }
+
     FString AssetName = BlueprintName;
     if (UEditorAssetLibrary::DoesAssetExist(PackagePath + AssetName))
     {
@@ -172,15 +227,15 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintCommands::HandleAddComponentToBluepri
     }
 
     FString ComponentType;
-    if (!Params->TryGetStringField(TEXT("component_type"), ComponentType))
+    if (!Params->TryGetStringField(TEXT("component_type"), ComponentType) && !Params->TryGetStringField(TEXT("type"), ComponentType))
     {
-        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'type' parameter"));
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'component_type' parameter"));
     }
 
     FString ComponentName;
-    if (!Params->TryGetStringField(TEXT("component_name"), ComponentName))
+    if (!Params->TryGetStringField(TEXT("component_name"), ComponentName) && !Params->TryGetStringField(TEXT("name"), ComponentName))
     {
-        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'name' parameter"));
+        return FUnrealMCPCommonUtils::CreateErrorResponse(TEXT("Missing 'component_name' parameter"));
     }
 
     // Find the blueprint
@@ -850,6 +905,140 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintCommands::HandleCompileBlueprint(cons
     return ResultObj;
 }
 
+TSharedPtr<FJsonObject> FUnrealMCPBlueprintCommands::HandleCompileBlueprintsAll(const TSharedPtr<FJsonObject>& Params)
+{
+    {
+        FString Err;
+        if (!IsSafeToCompileBlueprints(Err))
+        {
+            return FUnrealMCPCommonUtils::CreateErrorResponse(Err);
+        }
+    }
+
+    int32 Limit = 500;
+    if (Params->HasField(TEXT("limit")))
+    {
+        Limit = (int32)Params->GetNumberField(TEXT("limit"));
+    }
+    Limit = FMath::Clamp(Limit, 1, 10000);
+
+    bool bIncludeWarnings = true;
+    if (Params->HasField(TEXT("includeWarnings")))
+    {
+        bIncludeWarnings = Params->GetBoolField(TEXT("includeWarnings"));
+    }
+
+    TArray<FString> RootPaths;
+    if (Params->HasField(TEXT("paths")))
+    {
+        const TArray<TSharedPtr<FJsonValue>> PathsJson = Params->GetArrayField(TEXT("paths"));
+        for (const TSharedPtr<FJsonValue>& PathVal : PathsJson)
+        {
+            if (!PathVal.IsValid() || PathVal->Type != EJson::String) continue;
+            const FString P = PathVal->AsString().TrimStartAndEnd();
+            if (!P.IsEmpty())
+            {
+                RootPaths.Add(P);
+            }
+        }
+    }
+    if (RootPaths.Num() == 0)
+    {
+        RootPaths.Add(TEXT("/Game"));
+    }
+
+    FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>(TEXT("AssetRegistry"));
+    IAssetRegistry& AssetRegistry = AssetRegistryModule.Get();
+
+    FARFilter Filter;
+    Filter.bRecursivePaths = true;
+#if ENGINE_MAJOR_VERSION >= 5
+    Filter.ClassPaths.Add(UBlueprint::StaticClass()->GetClassPathName());
+#else
+    Filter.ClassNames.Add(UBlueprint::StaticClass()->GetFName());
+#endif
+    for (const FString& RootPath : RootPaths)
+    {
+        const FString Normalized = RootPath.StartsWith(TEXT("/")) ? RootPath : FString(TEXT("/")) + RootPath;
+        Filter.PackagePaths.Add(FName(*Normalized));
+    }
+
+    TArray<FAssetData> Assets;
+    AssetRegistry.GetAssets(Filter, Assets);
+
+    int32 TotalBlueprints = 0;
+    int32 Compiled = 0;
+    int32 Failed = 0;
+    int32 ErrorMessages = 0;
+    int32 WarningMessages = 0;
+
+    FMessageLogModule& MessageLogModule = FModuleManager::LoadModuleChecked<FMessageLogModule>(TEXT("MessageLog"));
+    const TSharedRef<IMessageLogListing> Listing = MessageLogModule.GetLogListing(TEXT("BlueprintLog"));
+
+    TArray<TSharedPtr<FJsonValue>> Results;
+
+    for (const FAssetData& Asset : Assets)
+    {
+        if (TotalBlueprints >= Limit) break;
+
+        UBlueprint* Blueprint = Cast<UBlueprint>(Asset.GetAsset());
+        if (!Blueprint) continue;
+
+        TotalBlueprints++;
+
+        Listing->ClearMessages();
+        FKismetEditorUtilities::CompileBlueprint(Blueprint);
+
+        const TArray<TSharedRef<FTokenizedMessage>>& Messages = Listing->GetFilteredMessages();
+        int32 BlueprintErrors = 0;
+        int32 BlueprintWarnings = 0;
+        TArray<TSharedPtr<FJsonValue>> MessageArray;
+
+        for (const TSharedRef<FTokenizedMessage>& Message : Messages)
+        {
+            const EMessageSeverity::Type Severity = Message->GetSeverity();
+            const bool bIsWarning =
+                Severity == EMessageSeverity::Warning || Severity == EMessageSeverity::PerformanceWarning;
+            const bool bIsError = Severity == EMessageSeverity::Error || Severity == EMessageSeverity::CriticalError;
+
+            if (bIsError) BlueprintErrors++;
+            if (bIsWarning) BlueprintWarnings++;
+
+            if (!bIncludeWarnings && bIsWarning) continue;
+
+            TSharedPtr<FJsonObject> Msg = MakeShared<FJsonObject>();
+            Msg->SetStringField(TEXT("severity"), MessageSeverityToString(Severity));
+            Msg->SetStringField(TEXT("message"), Message->ToText().ToString());
+            MessageArray.Add(MakeShared<FJsonValueObject>(Msg));
+        }
+
+        ErrorMessages += BlueprintErrors;
+        WarningMessages += BlueprintWarnings;
+
+        const bool bHadErrors = Blueprint->Status == BS_Error;
+        if (bHadErrors) Failed++; else Compiled++;
+
+        TSharedPtr<FJsonObject> Entry = MakeShared<FJsonObject>();
+        Entry->SetStringField(TEXT("name"), Blueprint->GetName());
+        Entry->SetStringField(TEXT("objectPath"), Asset.GetObjectPathString());
+        Entry->SetBoolField(TEXT("ok"), !bHadErrors);
+        Entry->SetNumberField(TEXT("errors"), BlueprintErrors);
+        Entry->SetNumberField(TEXT("warnings"), BlueprintWarnings);
+        Entry->SetArrayField(TEXT("messages"), MessageArray);
+        Results.Add(MakeShared<FJsonValueObject>(Entry));
+    }
+
+    TSharedPtr<FJsonObject> ResultObj = MakeShared<FJsonObject>();
+    ResultObj->SetNumberField(TEXT("found"), Assets.Num());
+    ResultObj->SetNumberField(TEXT("compiled"), Compiled);
+    ResultObj->SetNumberField(TEXT("failed"), Failed);
+    ResultObj->SetNumberField(TEXT("errors"), ErrorMessages);
+    ResultObj->SetNumberField(TEXT("warnings"), WarningMessages);
+    ResultObj->SetArrayField(TEXT("results"), Results);
+    ResultObj->SetBoolField(TEXT("truncated"), TotalBlueprints < Assets.Num() && TotalBlueprints >= Limit);
+    return ResultObj;
+}
+
 TSharedPtr<FJsonObject> FUnrealMCPBlueprintCommands::HandleSpawnBlueprintActor(const TSharedPtr<FJsonObject>& Params)
 {
     // Get required parameters
@@ -1157,4 +1346,4 @@ TSharedPtr<FJsonObject> FUnrealMCPBlueprintCommands::HandleSetPawnProperties(con
     ResponseObj->SetBoolField(TEXT("success"), bAnyPropertiesSet);
     ResponseObj->SetObjectField(TEXT("results"), ResultsObj);
     return ResponseObj;
-} 
+}