soft-ue-cli 1.3.2__tar.gz → 1.4.0__tar.gz

{soft_ue_cli-1.3.2 → soft_ue_cli-1.4.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: soft-ue-cli
-Version: 1.3.2
+Version: 1.4.0
 Summary: CLI tool for controlling Unreal Engine via soft-ue-bridge plugin
 Project-URL: Homepage, https://github.com/softdaddy-o/soft-ue-cli
 Project-URL: Repository, https://github.com/softdaddy-o/soft-ue-cli

{soft_ue_cli-1.3.2 → soft_ue_cli-1.4.0}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "hatchling.build"
 
 [project]
 name = "soft-ue-cli"
-version = "1.3.2"
+version = "1.4.0"
 description = "CLI tool for controlling Unreal Engine via soft-ue-bridge plugin"
 requires-python = ">=3.10"
 dependencies = [

{soft_ue_cli-1.3.2 → soft_ue_cli-1.4.0}/soft_ue_cli/__init__.py

@@ -1,3 +1,3 @@
 """soft-ue-cli — CLI interface to the SoftUEBridge UE plugin."""
 
-__version__ = "1.3.2"
+__version__ = "1.4.0"

{soft_ue_cli-1.3.2 → soft_ue_cli-1.4.0}/soft_ue_cli/__main__.py

@@ -67,6 +67,10 @@ def cmd_query_level(args: argparse.Namespace) -> None:
         arguments["tag_filter"] = args.tag
     if args.components:
         arguments["include_components"] = True
+    if args.include_properties or args.property_filter:
+        arguments["include_properties"] = True
+    if args.property_filter:
+        arguments["property_filter"] = args.property_filter
     _print_json(call_tool("query-level", arguments))
 
 
@@ -93,6 +97,18 @@ def cmd_set_property(args: argparse.Namespace) -> None:
     )
 
 
+def cmd_get_property(args: argparse.Namespace) -> None:
+    _print_json(
+        call_tool(
+            "get-property",
+            {
+                "actor_name": args.actor_name,
+                "property_name": args.property_name,
+            },
+        )
+    )
+
+
 def cmd_get_logs(args: argparse.Namespace) -> None:
     arguments: dict = {"lines": args.lines}
     if args.filter:
@@ -802,6 +818,8 @@ def cmd_create_asset(args: argparse.Namespace) -> None:
     }
     if args.parent_class:
         arguments["parent_class"] = args.parent_class
+    if args.skeleton:
+        arguments["skeleton"] = args.skeleton
     if args.row_struct:
         arguments["row_struct"] = args.row_struct
     _print_json(call_tool("create-asset", arguments))
@@ -1095,14 +1113,16 @@ def build_parser() -> argparse.ArgumentParser:
         description=(
             "Returns a JSON array of actors in the current game world.\n"
             "Each actor entry includes: name, class, location, rotation, scale, tags.\n"
-            "Use --components to also include the actor's component list.\n\n"
+            "Use --components to also include the actor's component list.\n"
+            "Use --include-properties to inspect actor and component property values.\n\n"
             "All filters are combined (AND logic). Wildcards (*) are supported in --search and --actor-name.\n\n"
             "EXAMPLES:\n"
             "  List all actors:                   soft-ue-cli query-level\n"
             "  Find all lights:                   soft-ue-cli query-level --class-filter PointLight\n"
             "  Find actor by name:                soft-ue-cli query-level --actor-name BP_Hero\n"
             '  Wildcard search:                   soft-ue-cli query-level --search "Enemy*"\n'
-            "  Tagged actors with components:     soft-ue-cli query-level --tag hostile --components"
+            "  Tagged actors with components:     soft-ue-cli query-level --tag hostile --components\n"
+            "  Actor with health properties:      soft-ue-cli query-level --actor-name BP_Hero --include-properties --property-filter '*Health*'"
         ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
@@ -1113,6 +1133,14 @@ def build_parser() -> argparse.ArgumentParser:
     p_ql.add_argument("--search", metavar="TEXT", help="Search actor names/labels (supports * wildcard)")
     p_ql.add_argument("--tag", metavar="TAG", help="Only return actors with this gameplay tag")
     p_ql.add_argument("--components", action="store_true", help="Include component list for each actor")
+    p_ql.add_argument(
+        "--include-properties", action="store_true",
+        help="Include actor and component properties (automatically enables --components)",
+    )
+    p_ql.add_argument(
+        "--property-filter", metavar="PATTERN",
+        help="Filter properties by name (wildcards supported, e.g., '*Health*'). Requires --include-properties.",
+    )
     p_ql.add_argument("--limit", type=int, default=100, metavar="N", help="Max actors to return (default: 100)")
     p_ql.set_defaults(func=cmd_query_level)
 
@@ -1159,6 +1187,26 @@ def build_parser() -> argparse.ArgumentParser:
     p_sp.add_argument("value", help="New value as a string (UE reflection converts the type)")
     p_sp.set_defaults(func=cmd_set_property)
 
+    # get-property (runtime actors)
+    p_gp = sub.add_parser(
+        "get-property",
+        help="Get a property value from a runtime actor or component using UE reflection.",
+        description=(
+            "Reads a UPROPERTY value from the named actor via UE's reflection system.\n"
+            "For component properties, use dot notation: ComponentName.PropertyName\n\n"
+            "Returns the property value as a string along with its type.\n\n"
+            "EXAMPLES:\n"
+            "  Actor property:     soft-ue-cli get-property PointLight_0 Intensity\n"
+            "  Component property: soft-ue-cli get-property BP_Hero LightComponent.Intensity\n"
+            "  Boolean:            soft-ue-cli get-property BP_Enemy bIsHostile\n"
+            "  Vector:             soft-ue-cli get-property BP_Hero RelativeScale3D"
+        ),
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+    )
+    p_gp.add_argument("actor_name", help="Actor name or label as shown in query-level output")
+    p_gp.add_argument("property_name", help="Property name, or ComponentName.PropertyName for component properties")
+    p_gp.set_defaults(func=cmd_get_property)
+
     # get-logs
     p_gl = sub.add_parser(
         "get-logs",
@@ -2110,13 +2158,15 @@ def build_parser() -> argparse.ArgumentParser:
             "EXAMPLES:\n"
             "  soft-ue-cli create-asset /Game/Blueprints/BP_NewActor Blueprint --parent-class Actor\n"
             "  soft-ue-cli create-asset /Game/Materials/M_NewMat Material\n"
-            "  soft-ue-cli create-asset /Game/Data/DT_Items DataTable --row-struct /Game/Structs/S_Item"
+            "  soft-ue-cli create-asset /Game/Data/DT_Items DataTable --row-struct /Game/Structs/S_Item\n"
+            "  soft-ue-cli create-asset /Game/Anim/ABP_Hero AnimBlueprint --skeleton /Game/Characters/SK_Mannequin"
         ),
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
     p_cas.add_argument("asset_path", help="Full asset path including name (e.g. /Game/Blueprints/BP_NewActor)")
     p_cas.add_argument("asset_class", help="Asset class (e.g. Blueprint, Material, DataTable, WidgetBlueprint)")
     p_cas.add_argument("--parent-class", metavar="CLASS", help="Parent class for Blueprints (e.g. Actor, Character)")
+    p_cas.add_argument("--skeleton", metavar="PATH", help="Skeleton asset path for AnimBlueprint (e.g. /Game/Characters/SK_Mannequin)")
     p_cas.add_argument("--row-struct", metavar="PATH", help="Row struct path for DataTables")
     p_cas.set_defaults(func=cmd_create_asset)
 
@@ -2126,10 +2176,11 @@ def build_parser() -> argparse.ArgumentParser:
 
     p_k = sub.add_parser(
         "query-ue-knowledge",
-        help="Query UE knowledge base (coming soon).",
+        help="Query the knowledge server for UE API docs and tutorials.",
         description="Coming soon. Follow https://github.com/softdaddy-o/soft-ue-cli for updates.",
         formatter_class=argparse.RawDescriptionHelpFormatter,
     )
+    p_k.add_argument("query", nargs="?", default=None, help="Natural language question about UE API or behavior")
     p_k.set_defaults(func=cmd_knowledge)
 
     # -------------------------------------------------------------------------

{soft_ue_cli-1.3.2 → soft_ue_cli-1.4.0}/soft_ue_cli/plugin_data/SoftUEBridge/Source/SoftUEBridge/Private/SoftUEBridgeModule.cpp

@@ -9,6 +9,7 @@
 #include "Tools/ConsoleVarTool.h"
 #include "Tools/SpawnActorTool.h"
 #include "Tools/SetPropertyTool.h"
+#include "Tools/GetPropertyTool.h"
 #include "Tools/TriggerInputTool.h"
 
 DEFINE_LOG_CATEGORY(LogSoftUEBridge);
@@ -25,6 +26,7 @@ void FSoftUEBridgeModule::StartupModule()
 	Registry.RegisterToolClass<USetConsoleVarTool>();
 	Registry.RegisterToolClass<USpawnActorTool>();
 	Registry.RegisterToolClass<USetPropertyTool>();
+	Registry.RegisterToolClass<UGetPropertyTool>();
 	Registry.RegisterToolClass<UTriggerInputTool>();
 
 	UE_LOG(LogSoftUEBridge, Log, TEXT("Registered %d runtime bridge tools"), Registry.GetToolCount());

soft_ue_cli-1.4.0/soft_ue_cli/plugin_data/SoftUEBridge/Source/SoftUEBridge/Private/Tools/GetPropertyTool.cpp

@@ -0,0 +1,123 @@
+// Copyright soft-ue-expert. All Rights Reserved.
+
+#include "Tools/GetPropertyTool.h"
+#include "Tools/BridgeToolRegistry.h"
+#include "SoftUEBridgeModule.h"
+#include "Engine/World.h"
+#include "GameFramework/Actor.h"
+#include "Components/ActorComponent.h"
+#include "EngineUtils.h"
+#include "UObject/UnrealType.h"
+
+#if !WITH_EDITOR
+REGISTER_BRIDGE_TOOL(UGetPropertyTool)
+#endif
+
+FString UGetPropertyTool::GetToolDescription() const
+{
+	return TEXT("Get a property value from an actor or its component using reflection. "
+		"Use dot notation for component properties: 'ComponentName.PropertyName'.");
+}
+
+TMap<FString, FBridgeSchemaProperty> UGetPropertyTool::GetInputSchema() const
+{
+	TMap<FString, FBridgeSchemaProperty> S;
+
+	auto Prop = [](const FString& Type, const FString& Desc, bool bReq = false) {
+		FBridgeSchemaProperty P;
+		P.Type = Type; P.Description = Desc; P.bRequired = bReq;
+		return P;
+	};
+
+	S.Add(TEXT("actor_name"),    Prop(TEXT("string"), TEXT("Actor name or label"), true));
+	S.Add(TEXT("property_name"), Prop(TEXT("string"), TEXT("Property name, or 'Component.Property' for component properties"), true));
+	S.Add(TEXT("world"),         Prop(TEXT("string"), TEXT("World context: 'editor' (editor scene), 'pie' (Play-In-Editor), 'game' (packaged build only). Omit to use the first available world.")));
+
+	return S;
+}
+
+FBridgeToolResult UGetPropertyTool::Execute(const TSharedPtr<FJsonObject>& Args, const FBridgeToolContext& Ctx)
+{
+	const FString ActorName    = GetStringArgOrDefault(Args, TEXT("actor_name"));
+	const FString PropertyName = GetStringArgOrDefault(Args, TEXT("property_name"));
+
+	UWorld* World = FindWorldByType(GetStringArgOrDefault(Args, TEXT("world")));
+	if (!World)
+	{
+		return FBridgeToolResult::Error(TEXT("No world available. Specify 'world': 'editor', 'pie', or 'game'."));
+	}
+
+	// Find actor
+	AActor* Actor = nullptr;
+	for (TActorIterator<AActor> It(World); It; ++It)
+	{
+		AActor* A = *It;
+		if (!A) continue;
+		if (MatchesWildcard(A->GetName(), ActorName) || MatchesWildcard(GetActorLabelSafe(A), ActorName))
+		{
+			Actor = A;
+			break;
+		}
+	}
+	if (!Actor)
+	{
+		return FBridgeToolResult::Error(FString::Printf(TEXT("Actor '%s' not found"), *ActorName));
+	}
+
+	// Resolve target object (actor or component via dot notation)
+	UObject* TargetObject = Actor;
+	FString PropKey = PropertyName;
+
+	int32 DotIdx;
+	if (PropertyName.FindChar(TEXT('.'), DotIdx))
+	{
+		const FString CompName = PropertyName.Left(DotIdx);
+		PropKey = PropertyName.Mid(DotIdx + 1);
+
+		TArray<UActorComponent*> Components;
+		Actor->GetComponents(Components);
+		for (UActorComponent* C : Components)
+		{
+			if (C && C->GetName().Equals(CompName, ESearchCase::IgnoreCase))
+			{
+				TargetObject = C;
+				break;
+			}
+		}
+
+		if (TargetObject == Actor)
+		{
+			return FBridgeToolResult::Error(
+				FString::Printf(TEXT("Component '%s' not found on '%s'"), *CompName, *ActorName));
+		}
+	}
+
+	// Find and read the property
+	for (TFieldIterator<FProperty> PropIt(TargetObject->GetClass()); PropIt; ++PropIt)
+	{
+		FProperty* Prop = *PropIt;
+		if (!Prop) continue;
+		if (!Prop->GetName().Equals(PropKey, ESearchCase::IgnoreCase)) continue;
+
+		void* ValuePtr = Prop->ContainerPtrToValuePtr<void>(TargetObject);
+		if (!ValuePtr)
+		{
+			return FBridgeToolResult::Error(TEXT("Failed to get property pointer"));
+		}
+
+		FString ExportedValue;
+		Prop->ExportText_Direct(ExportedValue, ValuePtr, ValuePtr, TargetObject, PPF_None);
+
+		TSharedPtr<FJsonObject> Result = MakeShareable(new FJsonObject);
+		Result->SetStringField(TEXT("actor"), Actor->GetName());
+		Result->SetStringField(TEXT("property"), PropertyName);
+		Result->SetStringField(TEXT("value"), ExportedValue);
+		Result->SetStringField(TEXT("type"), Prop->GetCPPType());
+
+		UE_LOG(LogSoftUEBridge, Log, TEXT("get-property: %s.%s = %s"), *ActorName, *PropertyName, *ExportedValue);
+		return FBridgeToolResult::Json(Result);
+	}
+
+	return FBridgeToolResult::Error(
+		FString::Printf(TEXT("Property '%s' not found on %s"), *PropKey, *TargetObject->GetClass()->GetName()));
+}

soft_ue_cli-1.4.0/soft_ue_cli/plugin_data/SoftUEBridge/Source/SoftUEBridge/Private/Tools/GetPropertyTool.h

@@ -0,0 +1,17 @@
+// Copyright soft-ue-expert. All Rights Reserved.
+
+#pragma once
+#include "Tools/BridgeToolBase.h"
+#include "GetPropertyTool.generated.h"
+
+UCLASS()
+class UGetPropertyTool : public UBridgeToolBase
+{
+	GENERATED_BODY()
+public:
+	virtual FString GetToolName() const override { return TEXT("get-property"); }
+	virtual FString GetToolDescription() const override;
+	virtual TMap<FString, FBridgeSchemaProperty> GetInputSchema() const override;
+	virtual TArray<FString> GetRequiredParams() const override { return {TEXT("actor_name"), TEXT("property_name")}; }
+	virtual FBridgeToolResult Execute(const TSharedPtr<FJsonObject>& Args, const FBridgeToolContext& Ctx) override;
+};

{soft_ue_cli-1.3.2 → soft_ue_cli-1.4.0}/soft_ue_cli/plugin_data/SoftUEBridge/Source/SoftUEBridge/Private/Tools/QueryLevelTool.cpp

@@ -7,6 +7,7 @@
 #include "GameFramework/Actor.h"
 #include "Components/ActorComponent.h"
 #include "EngineUtils.h"
+#include "UObject/UnrealType.h"
 
 #if !WITH_EDITOR
 REGISTER_BRIDGE_TOOL(UQueryLevelTool)
@@ -16,7 +17,8 @@ FString UQueryLevelTool::GetToolDescription() const
 {
 	return TEXT("List and inspect actors in the current game world. "
 		"Optionally filter by class, tag, or name pattern. "
-		"Use actor_name to get detailed info about a specific actor.");
+		"Use actor_name to get detailed info about a specific actor. "
+		"Use include_properties to inspect actor and component property values.");
 }
 
 TMap<FString, FBridgeSchemaProperty> UQueryLevelTool::GetInputSchema() const
@@ -37,6 +39,8 @@ TMap<FString, FBridgeSchemaProperty> UQueryLevelTool::GetInputSchema() const
 	S.Add(TEXT("include_components"),Prop(TEXT("boolean"), TEXT("Include component list (default: false)")));
 	S.Add(TEXT("include_transform"), Prop(TEXT("boolean"), TEXT("Include transforms (default: true)")));
 	S.Add(TEXT("include_hidden"),    Prop(TEXT("boolean"), TEXT("Include hidden actors (default: false)")));
+	S.Add(TEXT("include_properties"),Prop(TEXT("boolean"), TEXT("Include actor and component properties (default: false). Automatically enables component inclusion.")));
+	S.Add(TEXT("property_filter"),   Prop(TEXT("string"),  TEXT("Filter properties by name (wildcards supported, e.g., '*Health*'). Only used when include_properties is true.")));
 	S.Add(TEXT("limit"),             Prop(TEXT("integer"), TEXT("Max results (default: 100)")));
 	S.Add(TEXT("world"),             Prop(TEXT("string"),  TEXT("World context: 'editor' (editor scene), 'pie' (Play-In-Editor), 'game' (packaged build only). Omit to use the first available world.")));
 
@@ -55,9 +59,11 @@ FBridgeToolResult UQueryLevelTool::Execute(const TSharedPtr<FJsonObject>& Args,
 	const FString ClassFilter  = GetStringArgOrDefault(Args, TEXT("class_filter"));
 	const FString TagFilter    = GetStringArgOrDefault(Args, TEXT("tag_filter"));
 	const FString SearchFilter = GetStringArgOrDefault(Args, TEXT("search"));
-	const bool bComponents     = GetBoolArgOrDefault(Args, TEXT("include_components"), false);
+	const bool bProperties     = GetBoolArgOrDefault(Args, TEXT("include_properties"), false);
+	const bool bComponents     = GetBoolArgOrDefault(Args, TEXT("include_components"), false) || bProperties;
 	const bool bTransform      = GetBoolArgOrDefault(Args, TEXT("include_transform"), true);
 	const bool bHidden         = GetBoolArgOrDefault(Args, TEXT("include_hidden"), false);
+	const FString PropertyFilter = GetStringArgOrDefault(Args, TEXT("property_filter"));
 	const int32 Limit          = GetIntArgOrDefault(Args, TEXT("limit"), 100);
 
 	// Detail mode: find one specific actor
@@ -70,7 +76,7 @@ FBridgeToolResult UQueryLevelTool::Execute(const TSharedPtr<FJsonObject>& Args,
 			if (MatchesWildcard(Actor->GetName(), ActorName) ||
 				MatchesWildcard(GetActorLabelSafe(Actor), ActorName))
 			{
-				return FBridgeToolResult::Json(ActorToJson(Actor, true, true));
+				return FBridgeToolResult::Json(ActorToJson(Actor, true, true, bProperties, PropertyFilter));
 			}
 		}
 		return FBridgeToolResult::Error(FString::Printf(TEXT("Actor '%s' not found"), *ActorName));
@@ -108,7 +114,7 @@ FBridgeToolResult UQueryLevelTool::Execute(const TSharedPtr<FJsonObject>& Args,
 
 		if (ActorsArr.Num() >= Limit) { bLimitReached = true; break; }
 
-		TSharedPtr<FJsonObject> ActorJson = ActorToJson(Actor, bComponents, bTransform);
+		TSharedPtr<FJsonObject> ActorJson = ActorToJson(Actor, bComponents, bTransform, bProperties, PropertyFilter);
 		ActorsArr.Add(MakeShareable(new FJsonValueObject(ActorJson)));
 	}
 
@@ -121,7 +127,7 @@ FBridgeToolResult UQueryLevelTool::Execute(const TSharedPtr<FJsonObject>& Args,
 	return FBridgeToolResult::Json(Result);
 }
 
-TSharedPtr<FJsonObject> UQueryLevelTool::ActorToJson(AActor* Actor, bool bComponents, bool bTransform) const
+TSharedPtr<FJsonObject> UQueryLevelTool::ActorToJson(AActor* Actor, bool bComponents, bool bTransform, bool bProperties, const FString& PropertyFilter) const
 {
 	TSharedPtr<FJsonObject> J = MakeShareable(new FJsonObject);
 	J->SetStringField(TEXT("name"), Actor->GetName());
@@ -144,6 +150,12 @@ TSharedPtr<FJsonObject> UQueryLevelTool::ActorToJson(AActor* Actor, bool bCompon
 		J->SetArrayField(TEXT("tags"), Tags);
 	}
 
+	// Actor-level properties
+	if (bProperties)
+	{
+		J->SetArrayField(TEXT("properties"), CollectProperties(Actor, PropertyFilter));
+	}
+
 	if (bComponents)
 	{
 		TArray<TSharedPtr<FJsonValue>> Comps;
@@ -156,6 +168,13 @@ TSharedPtr<FJsonObject> UQueryLevelTool::ActorToJson(AActor* Actor, bool bCompon
 			CJ->SetStringField(TEXT("name"), C->GetName());
 			CJ->SetStringField(TEXT("class"), C->GetClass()->GetName());
 			CJ->SetBoolField(TEXT("is_active"), C->IsActive());
+
+			// Component-level properties
+			if (bProperties)
+			{
+				CJ->SetArrayField(TEXT("properties"), CollectProperties(C, PropertyFilter));
+			}
+
 			Comps.Add(MakeShareable(new FJsonValueObject(CJ)));
 		}
 		J->SetArrayField(TEXT("components"), Comps);
@@ -164,6 +183,31 @@ TSharedPtr<FJsonObject> UQueryLevelTool::ActorToJson(AActor* Actor, bool bCompon
 	return J;
 }
 
+TArray<TSharedPtr<FJsonValue>> UQueryLevelTool::CollectProperties(UObject* Object, const FString& PropertyFilter) const
+{
+	TArray<TSharedPtr<FJsonValue>> PropsArr;
+	for (TFieldIterator<FProperty> PropIt(Object->GetClass()); PropIt; ++PropIt)
+	{
+		FProperty* Prop = *PropIt;
+		if (!Prop) continue;
+
+		if (!PropertyFilter.IsEmpty() && !MatchesWildcard(Prop->GetName(), PropertyFilter))
+		{
+			continue;
+		}
+
+		void* ValuePtr = Prop->ContainerPtrToValuePtr<void>(Object);
+		if (!ValuePtr) continue;
+
+		TSharedPtr<FJsonObject> PropJson = PropertyToJson(Prop, ValuePtr, Object);
+		if (PropJson.IsValid())
+		{
+			PropsArr.Add(MakeShareable(new FJsonValueObject(PropJson)));
+		}
+	}
+	return PropsArr;
+}
+
 TSharedPtr<FJsonObject> UQueryLevelTool::TransformToJson(const FTransform& T) const
 {
 	auto Vec3 = [](const FVector& V) {
@@ -186,3 +230,63 @@ TSharedPtr<FJsonObject> UQueryLevelTool::TransformToJson(const FTransform& T) co
 	J->SetObjectField(TEXT("scale"), Vec3(T.GetScale3D()));
 	return J;
 }
+
+TSharedPtr<FJsonObject> UQueryLevelTool::PropertyToJson(FProperty* Property, void* Container, UObject* Owner) const
+{
+	if (!Property || !Container)
+	{
+		return nullptr;
+	}
+
+	TSharedPtr<FJsonObject> PropJson = MakeShareable(new FJsonObject);
+
+	PropJson->SetStringField(TEXT("name"), Property->GetName());
+	PropJson->SetStringField(TEXT("type"), GetPropertyTypeString(Property));
+
+	FString Value;
+	Property->ExportText_Direct(Value, Container, Container, Owner, PPF_None);
+	PropJson->SetStringField(TEXT("value"), Value);
+
+	return PropJson;
+}
+
+FString UQueryLevelTool::GetPropertyTypeString(FProperty* Property) const
+{
+	if (!Property)
+	{
+		return TEXT("unknown");
+	}
+
+	if (Property->IsA<FBoolProperty>()) return TEXT("bool");
+	if (Property->IsA<FIntProperty>()) return TEXT("int32");
+	if (Property->IsA<FFloatProperty>()) return TEXT("float");
+	if (Property->IsA<FNameProperty>()) return TEXT("FName");
+	if (Property->IsA<FStrProperty>()) return TEXT("FString");
+	if (Property->IsA<FTextProperty>()) return TEXT("FText");
+
+	if (FObjectProperty* ObjectProp = CastField<FObjectProperty>(Property))
+	{
+		if (ObjectProp->PropertyClass)
+		{
+			return FString::Printf(TEXT("TObjectPtr<%s>"), *ObjectProp->PropertyClass->GetName());
+		}
+		return TEXT("TObjectPtr<UObject>");
+	}
+
+	if (FStructProperty* StructProp = CastField<FStructProperty>(Property))
+	{
+		if (StructProp->Struct)
+		{
+			return StructProp->Struct->GetName();
+		}
+		return TEXT("struct");
+	}
+
+	if (FArrayProperty* ArrayProp = CastField<FArrayProperty>(Property))
+	{
+		FString InnerType = GetPropertyTypeString(ArrayProp->Inner);
+		return FString::Printf(TEXT("TArray<%s>"), *InnerType);
+	}
+
+	return Property->GetClass()->GetName();
+}

{soft_ue_cli-1.3.2 → soft_ue_cli-1.4.0}/soft_ue_cli/plugin_data/SoftUEBridge/Source/SoftUEBridge/Private/Tools/QueryLevelTool.h

@@ -15,6 +15,9 @@ public:
 	virtual FBridgeToolResult Execute(const TSharedPtr<FJsonObject>& Args, const FBridgeToolContext& Ctx) override;
 
 private:
-	TSharedPtr<FJsonObject> ActorToJson(AActor* Actor, bool bComponents, bool bTransform) const;
+	TSharedPtr<FJsonObject> ActorToJson(AActor* Actor, bool bComponents, bool bTransform, bool bProperties = false, const FString& PropertyFilter = TEXT("")) const;
 	TSharedPtr<FJsonObject> TransformToJson(const FTransform& T) const;
+	TArray<TSharedPtr<FJsonValue>> CollectProperties(UObject* Object, const FString& PropertyFilter) const;
+	TSharedPtr<FJsonObject> PropertyToJson(FProperty* Property, void* Container, UObject* Owner) const;
+	FString GetPropertyTypeString(FProperty* Property) const;
 };

{soft_ue_cli-1.3.2 → soft_ue_cli-1.4.0}/soft_ue_cli/plugin_data/SoftUEBridge/Source/SoftUEBridgeEditor/Private/Tools/Asset/DeleteAssetTool.cpp

@@ -1,10 +1,12 @@
 // Copyright softdaddy-o 2024. All Rights Reserved.
 
 #include "Tools/Asset/DeleteAssetTool.h"
+#include "Utils/BridgeAssetModifier.h"
 #include "SoftUEBridgeEditorModule.h"
 #include "Engine/Blueprint.h"
 #include "UObject/UObjectGlobals.h"
 #include "EditorAssetLibrary.h"
+#include "AssetRegistry/AssetRegistryModule.h"
 
 FString UDeleteAssetTool::GetToolDescription() const
 {
@@ -40,7 +42,50 @@ FBridgeToolResult UDeleteAssetTool::Execute(
 	UObject* Asset = UEditorAssetLibrary::LoadAsset(AssetPath);
 	if (!Asset)
 	{
-		return FBridgeToolResult::Error(FString::Printf(TEXT("Asset not found: %s"), *AssetPath));
+		// Check for phantom asset: registry has entry but LoadAsset fails
+		if (FBridgeAssetModifier::AssetExists(AssetPath))
+		{
+			UE_LOG(LogSoftUEBridgeEditor, Warning, TEXT("delete-asset: Phantom asset detected at %s (registry entry but not loadable). Cleaning up."), *AssetPath);
+
+			// Force rescan and retry load
+			FAssetRegistryModule& AssetRegistryModule = FModuleManager::LoadModuleChecked<FAssetRegistryModule>("AssetRegistry");
+			TArray<FString> ScanPaths = { FPackageName::GetLongPackagePath(AssetPath) };
+			AssetRegistryModule.Get().ScanPathsSynchronous(ScanPaths, /*bForceRescan=*/true);
+			Asset = UEditorAssetLibrary::LoadAsset(AssetPath);
+
+			if (!Asset)
+			{
+				// Still can't load — remove the stale registry entry by rescanning
+				// Delete the on-disk package file if it exists
+				FString PackageFilename;
+				if (FPackageName::DoesPackageExist(AssetPath, &PackageFilename))
+				{
+					if (IFileManager::Get().Delete(*PackageFilename))
+					{
+						UE_LOG(LogSoftUEBridgeEditor, Log, TEXT("delete-asset: Deleted orphan package file: %s"), *PackageFilename);
+					}
+					else
+					{
+						UE_LOG(LogSoftUEBridgeEditor, Warning, TEXT("delete-asset: Failed to delete orphan package file: %s"), *PackageFilename);
+					}
+				}
+
+				// Rescan to purge the registry entry
+				AssetRegistryModule.Get().ScanPathsSynchronous(ScanPaths, /*bForceRescan=*/true);
+
+				TSharedPtr<FJsonObject> Result = MakeShareable(new FJsonObject);
+				Result->SetStringField(TEXT("asset_path"), AssetPath);
+				Result->SetBoolField(TEXT("success"), true);
+				Result->SetStringField(TEXT("message"), FString::Printf(TEXT("Phantom asset cleaned up: %s"), *AssetPath));
+				Result->SetBoolField(TEXT("was_phantom"), true);
+				return FBridgeToolResult::Json(Result);
+			}
+			// Rescan fixed the load — fall through to normal deletion
+		}
+		else
+		{
+			return FBridgeToolResult::Error(FString::Printf(TEXT("Asset not found: %s"), *AssetPath));
+		}
 	}
 
 	bool bIsBlueprint = Asset->IsA<UBlueprint>();

{soft_ue_cli-1.3.2 → soft_ue_cli-1.4.0}/soft_ue_cli/plugin_data/SoftUEBridge/Source/SoftUEBridgeEditor/Private/Tools/Blueprint/QueryBlueprintGraphTool.cpp

@@ -74,7 +74,7 @@ TMap<FString, FBridgeSchemaProperty> UQueryBlueprintGraphTool::GetInputSchema()
 
 	FBridgeSchemaProperty GraphType;
 	GraphType.Type = TEXT("string");
-	GraphType.Description = TEXT("Filter by graph type: 'event', 'function', 'macro', or for AnimBlueprints: 'anim_graph', 'state_machine', 'state', 'transition', 'blend_stack'");
+	GraphType.Description = TEXT("Filter by graph type: 'event', 'function', 'macro', 'interface', or for AnimBlueprints: 'anim_graph', 'state_machine', 'state', 'transition', 'blend_stack'");
 	GraphType.bRequired = false;
 	Schema.Add(TEXT("graph_type"), GraphType);
 
@@ -291,6 +291,25 @@ FBridgeToolResult UQueryBlueprintGraphTool::Execute(
 		}
 	}
 
+	// Interface implementation graphs
+	if (GraphTypeFilter.IsEmpty() || GraphTypeFilter == TEXT("interface"))
+	{
+		for (const FBPInterfaceDescription& InterfaceDesc : Blueprint->ImplementedInterfaces)
+		{
+			if (!InterfaceDesc.Interface) continue;
+			for (UEdGraph* Graph : InterfaceDesc.Graphs)
+			{
+				if (!Graph) continue;
+				if (!GraphNameFilter.IsEmpty() && Graph->GetName() != GraphNameFilter) continue;
+				TSharedPtr<FJsonObject> GraphJson = GraphToJson(Graph, TEXT("interface"), SerializeOptions, SearchFilter);
+				if (GraphJson.IsValid())
+				{
+					GraphsArray.Add(MakeShareable(new FJsonValueObject(GraphJson)));
+				}
+			}
+		}
+	}
+
 	// Animation Blueprint specific graphs
 	if (bIsAnimBlueprint)
 	{
@@ -501,6 +520,25 @@ UEdGraphNode* UQueryBlueprintGraphTool::FindNodeByGuid(UBlueprint* Blueprint, co
 		}
 	}
 
+	// Search interface implementation graphs
+	for (const FBPInterfaceDescription& InterfaceDesc : Blueprint->ImplementedInterfaces)
+	{
+		if (!InterfaceDesc.Interface) continue;
+		for (UEdGraph* Graph : InterfaceDesc.Graphs)
+		{
+			if (!Graph) continue;
+			for (UEdGraphNode* Node : Graph->Nodes)
+			{
+				if (Node && Node->NodeGuid == NodeGuid)
+				{
+					OutGraphName = Graph->GetName();
+					OutGraphType = TEXT("interface");
+					return Node;
+				}
+			}
+		}
+	}
+
 	return nullptr;
 }
 
@@ -567,6 +605,21 @@ UEdGraph* UQueryBlueprintGraphTool::FindGraphByName(UBlueprint* Blueprint, const
 		}
 	}
 
+	// Search interface implementation graphs
+	for (const FBPInterfaceDescription& InterfaceDesc : Blueprint->ImplementedInterfaces)
+	{
+		if (!InterfaceDesc.Interface) continue;
+		for (UEdGraph* Graph : InterfaceDesc.Graphs)
+		{
+			if (!Graph) continue;
+			if (Graph->GetName().Equals(CallableName, ESearchCase::IgnoreCase))
+			{
+				OutGraphType = TEXT("interface");
+				return Graph;
+			}
+		}
+	}
+
 	return nullptr;
 }