Refactoring ue-wingman to be a command-line only tool

Plugins/UEWingman/BrokenHandlers/Details_SetMany.h

@@ -0,0 +1,60 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "WingServer.h"
+#include "WingBasics.h"
+#include "WingFetcher.h"
+#include "WingProperty.h"
+#include "WingUtils.h"
+#include "Details_SetMany.generated.h"
+
+UCLASS()
+class UWing_Details_SetMany : public UWingHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(EditAnywhere, meta=(Description="Target object"))
+	FString Object;
+
+	UPROPERTY(EditAnywhere, meta=(Description="Object mapping property names to new values in Unreal text format"))
+	FWingJsonObject Properties;
+
+	virtual void Register() override
+	{
+		UWingServer::AddHandler(this,
+			TEXT("Set one or more editable properties. Values use Unreal text format."));
+	}
+
+	virtual void Handle() override
+	{
+		WingFetcher F(WingOut::Stdout);
+		UObject* Obj = F.Walk(Object).Cast<UObject>();
+		if (!Obj) return;
+
+		if (!Properties.Json || Properties.Json->Values.Num() == 0)
+		{
+			WingOut::Stdout.Print(TEXT("Error: No properties specified\n"));
+			return;
+		}
+
+		TArray<FWingProperty> Props = FWingProperty::GetDetails(Obj, true);
+
+		// Validation pass — resolve all properties before modifying anything.
+		for (const auto& Pair : Properties.Json->Values)
+		{
+			FWingProperty* P = WingUtils::FindOneWithExternalID(Pair.Key, Props, TEXT("Property"), WingOut::Stdout);
+			if (!P) return;
+		}
+
+		// Assignment pass — store the values.
+		int SuccessCount = 0;
+		for (const auto& Pair : Properties.Json->Values)
+		{
+			FWingProperty* P = WingUtils::FindOneWithExternalID(Pair.Key, Props, TEXT("Property"), WingOut::Stdout);
+			if (P->SetJson(*Pair.Value, WingOut::Stdout)) SuccessCount++;
+		}
+
+		WingOut::Stdout.Printf(TEXT("Set %d/%d properties.\n"), SuccessCount, Properties.Json->Values.Num());
+	}
+};

Plugins/UEWingman/BrokenHandlers/GraphNode_Add.h

@@ -0,0 +1,95 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "WingServer.h"
+#include "WingBasics.h"
+#include "WingFetcher.h"
+#include "WingProperty.h"
+#include "WingUtils.h"
+#include "WingGraphActions.h"
+#include "WingGraphExport.h"
+#include "EdGraph/EdGraph.h"
+#include "GraphNode_Add.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+USTRUCT()
+struct FSpawnNodeEntry
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	FString Type;
+
+	UPROPERTY()
+	int32 PosX = 0;
+
+	UPROPERTY()
+	int32 PosY = 0;
+
+	FWingGraphAction *Action;
+};
+
+
+UCLASS()
+class UWing_GraphNode_Add : public UWingHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(EditAnywhere, meta=(Description="Target graph"))
+	FString Graph;
+
+	UPROPERTY(EditAnywhere, meta=(Description="Array of {Type, posX, posY} objects. Use GraphNode_SearchTypes to find types."))
+	FWingJsonArray Nodes;
+
+	virtual void Register() override
+	{
+		UWingServer::AddHandler(this,
+			TEXT("Create nodes using the editor's action database. "
+			"Use GraphNode_SearchTypes to find types."));
+	}
+	virtual void Handle() override
+	{
+		WingFetcher F(WingOut::Stdout);
+		UEdGraph* TargetGraph = F.Walk(Graph).Cast<UEdGraph>();
+		if (!TargetGraph) return;
+
+		int32 SuccessCount = 0;
+		int32 TotalCount = Nodes.Array.Num();
+		FWingGraphActions GraphActions(TargetGraph);
+
+		// Parse the json array, turning it into an array of spawn node entries.
+		TArray<FSpawnNodeEntry> Entries;
+		FSpawnNodeEntry Entry;
+		TArray<FWingProperty> Props = FWingProperty::GetAll(nullptr, &Entry, FSpawnNodeEntry::StaticStruct(), true);
+		for (const TSharedPtr<FJsonValue>& Elt : Nodes.Array)
+		{
+			if (!FWingProperty::PopulateFromJson(Props, *Elt, false, WingOut::Stdout)) return;
+			TArray<FWingGraphAction*> Results = GraphActions.Search(Entry.Type, 2, true);
+			if (!WingUtils::CheckExactlyOneNamed(Results.Num(), TEXT("node type"), Entry.Type, WingOut::Stdout)) return;
+			Entry.Action = Results[0];
+			Entries.Add(Entry);
+		}
+
+		// Execute all.
+		for (const FSpawnNodeEntry &SpawnEntry : Entries)
+		{
+			UEdGraphNode* NewNode = SpawnEntry.Action->Execute(FVector2D(SpawnEntry.PosX, SpawnEntry.PosY));
+			if (NewNode)
+			{
+				WingOut::Stdout.Printf(TEXT("Spawned: %s\n"), *SpawnEntry.Type);
+				WingGraphExport Export(NewNode, false, true);
+				WingOut::Stdout.Print(Export.GetOutput());
+			}
+			else
+			{
+				WingOut::Stdout.Printf(TEXT("Failed: %s\n\n"), *SpawnEntry.Type);
+				continue;
+			}
+		}
+	}
+};

Plugins/UEWingman/BrokenHandlers/GraphNode_SearchTypes.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "WingServer.h"
+#include "WingBasics.h"
+#include "WingFetcher.h"
+#include "WingGraphActions.h"
+#include "EdGraph/EdGraph.h"
+#include "GraphNode_SearchTypes.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS()
+class UWing_GraphNode_SearchTypes : public UWingHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(EditAnywhere, meta=(Description="Array of query strings; each may contain * wildcards"))
+	FWingJsonArray Queries;
+
+	UPROPERTY(EditAnywhere, meta=(Optional, Description="Maximum number of results per query (default 50)"))
+	int32 MaxResults = 50;
+
+	UPROPERTY(EditAnywhere, meta=(Description="Target graph"))
+	FString Graph;
+
+	virtual void Register() override
+	{
+		UWingServer::AddHandler(this,
+			TEXT("Search for node types that can be spawned in a graph. "
+				"Pass a string returned by this function to GraphNode_Add."));
+	}
+	virtual void Handle() override
+	{
+		WingFetcher F(WingOut::Stdout);
+		UEdGraph* TargetGraph = F.Walk(Graph).Cast<UEdGraph>();
+		if (!TargetGraph) return;
+
+		// Validate all entries are strings before running any searches.
+		TArray<FString> QueryStrings;
+		QueryStrings.Reserve(Queries.Array.Num());
+		for (const TSharedPtr<FJsonValue>& QueryVal : Queries.Array)
+		{
+			FString QueryStr;
+			if (!QueryVal->TryGetString(QueryStr))
+			{
+				WingOut::Stdout.Print(TEXT("ERROR: Queries must be an array of strings.\n"));
+				return;
+			}
+			QueryStrings.Add(QueryStr);
+		}
+
+		FWingGraphActions GraphActions(TargetGraph);
+		for (const FString& Query : QueryStrings)
+		{
+			WingOut::Stdout.Printf(TEXT("\n=== %s ===\n\n"), *Query);
+			TArray<FWingGraphAction*> Results = GraphActions.Search(Query, MaxResults, false);
+			for (const FWingGraphAction* Action : Results)
+			{
+				WingOut::Stdout.Printf(TEXT("%s\n"), *Action->Name);
+			}
+
+			if (Results.Num() == 0)
+			{
+				WingOut::Stdout.Print(TEXT("No matching node types found.\n"));
+			}
+			else if (Results.Num() >= MaxResults)
+			{
+				WingOut::Stdout.Printf(TEXT("WARNING: Reached limit of %d results. You may specify MaxResults.\n"), MaxResults);
+			}
+		}
+	}
+};

Plugins/UEWingman/BrokenHandlers/GraphNode_SetDefaults.h

@@ -0,0 +1,136 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "WingBasics.h"
+#include "WingServer.h"
+#include "WingFetcher.h"
+#include "WingProperty.h"
+#include "WingUtils.h"
+#include "EdGraph/EdGraphPin.h"
+#include "EdGraphSchema_K2.h"
+#include "MaterialGraph/MaterialGraphSchema.h"
+#include "GraphNode_SetDefaults.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+USTRUCT()
+struct FSetNodeDefaultEntry
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	FString Node;
+
+	UPROPERTY()
+	FString Name;
+
+	UPROPERTY()
+	FString Value;
+};
+
+
+UCLASS()
+class UWing_GraphNode_SetDefaults : public UWingHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(EditAnywhere, meta=(Description="Target graph"))
+	FString Graph;
+
+	UPROPERTY(EditAnywhere, meta=(Description="Array of {node, name, value} objects"))
+	FWingJsonArray Pins;
+
+	virtual void Register() override
+	{
+		UWingServer::AddHandler(this,
+			TEXT("Set the default value of input pins or material expression properties on nodes."));
+	}
+	// -----------------------------------------------------------------------
+	// K2 graphs: set pin default values.
+	// -----------------------------------------------------------------------
+
+	void HandleK2Entry(const FSetNodeDefaultEntry& Entry, UEdGraph* GraphObj, const UEdGraphSchema_K2* K2Schema)
+	{
+		WingFetcher F(GraphObj, WingOut::Stdout);
+		UWingGraphPinRef* PinRef = F.Node(Entry.Node).Pin(Entry.Name).Cast<UWingGraphPinRef>();
+		if (!PinRef) return;
+		UEdGraphPin* Pin = WingUtils::CheckGetPin(PinRef->Node, PinRef->PinName, WingOut::Stdout);
+		if (!Pin) return;
+
+		UEdGraphNode* Node = Pin->GetOwningNode();
+
+		if (Pin->Direction != EGPD_Input)
+		{
+			WingOut::Stdout.Printf(TEXT("error: %s is an output pin\n"), *WingUtils::FormatName(Pin));
+			return;
+		}
+
+		FString UseDefaultValue;
+		TObjectPtr<UObject> UseDefaultObject = nullptr;
+		FText UseDefaultText;
+		K2Schema->GetPinDefaultValuesFromString(Pin->PinType, Node, Entry.Value, UseDefaultValue, UseDefaultObject, UseDefaultText, false);
+		FString Error = K2Schema->IsPinDefaultValid(Pin, UseDefaultValue, UseDefaultObject, UseDefaultText);
+		if (!Error.IsEmpty())
+		{
+			WingOut::Stdout.Printf(TEXT("error: %s: %s\n"), *WingUtils::FormatName(Pin), *Error);
+			return;
+		}
+		UWingServer::AddTouchedObject(Node);
+		K2Schema->TrySetDefaultValue(*Pin, Entry.Value);
+	}
+
+	// -----------------------------------------------------------------------
+	// Material graphs: set material expression properties.
+	// -----------------------------------------------------------------------
+
+	void HandleMaterialEntry(const FSetNodeDefaultEntry& Entry, UEdGraph* GraphObj)
+	{
+		WingFetcher F(GraphObj, WingOut::Stdout);
+		UEdGraphNode* Node = F.Node(Entry.Node).Cast<UEdGraphNode>();
+		if (!Node) return;
+
+		TArray<FWingProperty> All = FWingProperty::GetDetails(Node, true);
+		FWingProperty *P = WingUtils::FindOneWithExternalID(Entry.Name, All, TEXT("Property"), WingOut::Stdout);
+		if (!P) return;
+
+		UWingServer::AddTouchedObject(Node);
+
+		if (!P->SetText(Entry.Value, WingOut::Stdout))
+			return;
+	}
+
+	// -----------------------------------------------------------------------
+
+	virtual void Handle() override
+	{
+		// Fetch the graph once.
+		WingFetcher GraphFetcher(WingOut::Stdout);
+		UEdGraph* GraphObj = GraphFetcher.Walk(Graph).Cast<UEdGraph>();
+		if (!GraphObj) return;
+
+		const UEdGraphSchema* Schema = GraphObj->GetSchema();
+		const UEdGraphSchema_K2* K2Schema = Cast<UEdGraphSchema_K2>(Schema);
+		const UMaterialGraphSchema* MGSchema = Cast<UMaterialGraphSchema>(Schema);
+
+		if (!K2Schema && !MGSchema)
+		{
+			WingOut::Stdout.Printf(TEXT("error: unsupported graph schema %s\n"), *Schema->GetClass()->GetName());
+			return;
+		}
+
+		FSetNodeDefaultEntry Entry;
+		TArray<FWingProperty> Props = FWingProperty::GetAll(nullptr, &Entry, FSetNodeDefaultEntry::StaticStruct(), true);
+		for (const TSharedPtr<FJsonValue>& PinVal : Pins.Array)
+		{
+			if (!FWingProperty::PopulateFromJson(Props, *PinVal, false, WingOut::Stdout)) continue;
+			if (K2Schema) HandleK2Entry(Entry, GraphObj, K2Schema);
+			else if (MGSchema) HandleMaterialEntry(Entry, GraphObj);
+		}
+
+		WingOut::Stdout.Printf(TEXT("Done.\n"));
+	}
+};

Plugins/UEWingman/BrokenHandlers/GraphNode_SetPositions.h

@@ -0,0 +1,73 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "WingServer.h"
+#include "WingBasics.h"
+#include "WingFetcher.h"
+#include "WingProperty.h"
+#include "EdGraph/EdGraph.h"
+#include "EdGraph/EdGraphNode.h"
+#include "GraphNode_SetPositions.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+USTRUCT()
+struct FMoveNodeEntry
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	FString Node;
+
+	UPROPERTY()
+	int32 X = 0;
+
+	UPROPERTY()
+	int32 Y = 0;
+};
+
+
+UCLASS()
+class UWing_GraphNode_SetPositions : public UWingHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(EditAnywhere, meta=(Description="Target graph"))
+	FString Graph;
+
+	UPROPERTY(EditAnywhere, meta=(Description="Array of {node, x, y} objects"))
+	FWingJsonArray Nodes;
+
+	virtual void Register() override
+	{
+		UWingServer::AddHandler(this,
+			TEXT("Reposition one or more nodes in a Blueprint graph."));
+	}
+	virtual void Handle() override
+	{
+		WingFetcher F(WingOut::Stdout);
+		UEdGraph* TargetGraph = F.Walk(Graph).Cast<UEdGraph>();
+		if (!TargetGraph) return;
+
+		int32 SuccessCount = 0;
+
+		FMoveNodeEntry Entry;
+		TArray<FWingProperty> Props = FWingProperty::GetAll(nullptr, &Entry, FMoveNodeEntry::StaticStruct(), true);
+		for (const TSharedPtr<FJsonValue>& Elt : Nodes.Array)
+		{
+			if (!FWingProperty::PopulateFromJson(Props, *Elt, false, WingOut::Stdout)) continue;
+			WingFetcher FN(TargetGraph, WingOut::Stdout);
+			UEdGraphNode* Node = FN.Node(Entry.Node).Cast<UEdGraphNode>();
+			if (!Node) continue;
+			Node->NodePosX = Entry.X;
+			Node->NodePosY = Entry.Y;
+			SuccessCount++;
+		}
+
+		WingOut::Stdout.Printf(TEXT("Moved %d/%d nodes.\n"), SuccessCount, Nodes.Array.Num());
+	}
+};

Plugins/UEWingman/BrokenHandlers/GraphPin_Connect.h

@@ -0,0 +1,96 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "WingServer.h"
+#include "WingBasics.h"
+#include "WingFetcher.h"
+#include "WingProperty.h"
+#include "WingUtils.h"
+#include "EdGraph/EdGraph.h"
+#include "EdGraph/EdGraphSchema.h"
+#include "EdGraph/EdGraphPin.h"
+#include "GraphPin_Connect.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+USTRUCT()
+struct FConnectPinsEntry
+{
+	GENERATED_BODY()
+
+	UPROPERTY()
+	FString SourcePin;
+
+	UPROPERTY()
+	FString TargetPin;
+};
+
+
+UCLASS()
+class UWing_GraphPin_Connect : public UWingHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(EditAnywhere, meta=(Description="Target graph"))
+	FString Graph;
+
+	UPROPERTY(EditAnywhere, meta=(Description="Array of {sourcePin, targetPin} objects"))
+	FWingJsonArray Connections;
+
+	virtual void Register() override
+	{
+		UWingServer::AddHandler(this,
+			TEXT("Connect pins between nodes in a graph (Blueprint or Material). "
+			     "Pin IDs use fetcher path syntax relative to the graph, eg: "
+			     "node:K2Node_CallFunction_0,pin:ReturnValue"));
+	}
+	virtual void Handle() override
+	{
+		WingFetcher F(WingOut::Stdout);
+		UEdGraph* G = F.Walk(Graph).Cast<UEdGraph>();
+		if (!G) return;
+
+		int32 SuccessCount = 0;
+		int32 TotalCount = Connections.Array.Num();
+
+		FConnectPinsEntry Entry;
+		TArray<FWingProperty> EntryProps = FWingProperty::GetAll(nullptr, &Entry, FConnectPinsEntry::StaticStruct(), true);
+		for (const TSharedPtr<FJsonValue>& ConnVal : Connections.Array)
+		{
+			if (!FWingProperty::PopulateFromJson(EntryProps, *ConnVal, false, WingOut::Stdout))
+				continue;
+
+			WingFetcher FS(G, WingOut::Stdout);
+			UWingGraphPinRef* SourcePinRef = FS.Walk(Entry.SourcePin).Cast<UWingGraphPinRef>();
+			if (!SourcePinRef) continue;
+			UEdGraphPin* SourcePin = WingUtils::CheckGetPin(SourcePinRef->Node, SourcePinRef->PinName, WingOut::Stdout);
+			if (!SourcePin) continue;
+
+			WingFetcher FT(G, WingOut::Stdout);
+			UWingGraphPinRef* TargetPinRef = FT.Walk(Entry.TargetPin).Cast<UWingGraphPinRef>();
+			if (!TargetPinRef) continue;
+			UEdGraphPin* TargetPin = WingUtils::CheckGetPin(TargetPinRef->Node, TargetPinRef->PinName, WingOut::Stdout);
+			if (!TargetPin) continue;
+
+			const UEdGraphSchema* Schema = G->GetSchema();
+			const FPinConnectionResponse Response = Schema->CanCreateConnection(SourcePin, TargetPin);
+			if (Response.Response == CONNECT_RESPONSE_DISALLOW)
+			{
+				WingOut::Stdout.Printf(TEXT("error: Cannot connect %s.%s to %s.%s: %s\n"),
+					*WingUtils::FormatName(SourcePin->GetOwningNode()), *WingUtils::FormatName(SourcePin),
+					*WingUtils::FormatName(TargetPin->GetOwningNode()), *WingUtils::FormatName(TargetPin),
+					*Response.Message.ToString());
+				continue;
+			}
+
+			Schema->TryCreateConnection(SourcePin, TargetPin);
+			SuccessCount++;
+		}
+
+		WingOut::Stdout.Printf(TEXT("Connected %d/%d pins.\n"), SuccessCount, TotalCount);
+	}
+};

Plugins/UEWingman/BrokenHandlers/GraphPin_Disconnect.h

@@ -0,0 +1,77 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "WingServer.h"
+#include "WingBasics.h"
+#include "WingFetcher.h"
+#include "WingProperty.h"
+#include "WingUtils.h"
+#include "EdGraph/EdGraph.h"
+#include "EdGraph/EdGraphPin.h"
+#include "GraphPin_Disconnect.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS()
+class UWing_GraphPin_Disconnect : public UWingHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(EditAnywhere, meta=(Description="Target graph"))
+	FString Graph;
+
+	UPROPERTY(EditAnywhere, meta=(Description="Array of pin ID strings"))
+	FWingJsonArray Pins;
+
+	virtual void Register() override
+	{
+		UWingServer::AddHandler(this,
+			TEXT("Disconnect all connections on the specified pins. "
+			"Pin IDs use fetcher path syntax relative to the graph, eg: "
+			"node:K2Node_CallFunction_0,pin:ReturnValue"));
+	}
+	virtual void Handle() override
+	{
+		WingFetcher F(WingOut::Stdout);
+		UEdGraph* G = F.Walk(Graph).Cast<UEdGraph>();
+		if (!G) return;
+
+		int32 SuccessCount = 0;
+		int32 TotalDisconnected = 0;
+
+		for (const TSharedPtr<FJsonValue>& PinVal : Pins.Array)
+		{
+			FString PinPath;
+			if (!PinVal->TryGetString(PinPath))
+			{
+				WingOut::Stdout.Print(TEXT("ERROR: Expected a string pin ID.\n"));
+				continue;
+			}
+
+			WingFetcher FP(G, WingOut::Stdout);
+			UWingGraphPinRef* PinRef = FP.Walk(PinPath).Cast<UWingGraphPinRef>();
+			if (!PinRef) continue;
+			UEdGraphPin* Pin = WingUtils::CheckGetPin(PinRef->Node, PinRef->PinName, WingOut::Stdout);
+			if (!Pin) continue;
+
+			int32 DisconnectedCount = Pin->LinkedTo.Num();
+			if (DisconnectedCount > 0)
+			{
+				Pin->BreakAllPinLinks(true);
+			}
+
+			WingOut::Stdout.Printf(TEXT("Disconnected %d link(s) from %s.%s\n"),
+				DisconnectedCount,
+				*WingUtils::FormatName(Pin->GetOwningNode()), *WingUtils::FormatName(Pin));
+			SuccessCount++;
+			TotalDisconnected += DisconnectedCount;
+		}
+
+		WingOut::Stdout.Printf(TEXT("Done: %d/%d succeeded, %d links broken.\n"),
+			SuccessCount, Pins.Array.Num(), TotalDisconnected);
+	}
+};

Plugins/UEWingman/BrokenHandlers/Sequence.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "WingServer.h"
+#include "WingBasics.h"
+#include "Sequence.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS()
+class UWing_Sequence : public UWingHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(EditAnywhere, meta=(Description=
+		"Array of subcommand JSON objects to execute in order. Each must contain 'command' and its parameters."))
+	FWingJsonArray Subcommands;
+
+	virtual void Register() override
+	{
+		UWingServer::AddHandler(this,
+			TEXT("Execute multiple commands in one request. Each subcommand "
+				"produces its own content block in the response. The big win "
+				"performance-wise is that fewer MCP calls means fewer "
+				"round-trip invocations of the LLM."));
+	}
+	virtual void Handle() override
+	{
+		// The actual code that implements Sequence is hardwired into
+		// WingServer. Because of that, this handler is never actually called
+		// under normal conditions.  The handler exists for two reasons: to
+		// provide documentation, and also to catch the case where somebody
+		// nests a sequence inside another sequence.
+		WingOut::Stdout.Print(
+			TEXT("ERROR: Sequence inside a Sequence is not allowed.\n"));
+	}
+};

Plugins/UEWingman/BrokenHandlers/Widget_SearchTypes.h

@@ -0,0 +1,68 @@
+#pragma once
+
+#include "CoreMinimal.h"
+#include "WingServer.h"
+#include "WingBasics.h"
+#include "WingWidgets.h"
+#include "Widget_SearchTypes.generated.h"
+
+
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+// ---------------------------------------------------------------------------
+
+UCLASS()
+class UWing_Widget_SearchTypes : public UWingHandler
+{
+	GENERATED_BODY()
+
+public:
+	UPROPERTY(EditAnywhere, meta=(Description="Array of query strings; each may contain *"))
+	FWingJsonArray Queries;
+
+	UPROPERTY(EditAnywhere, meta=(Optional, Description="Maximum number of results per query (default 50)"))
+	int32 MaxResults = 50;
+
+	virtual void Register() override
+	{
+		UWingServer::AddHandler(this,
+			TEXT("Search for widget types that can be added to a Widget Blueprint. "
+			"Returns names for use with Widget_Add."));
+	}
+	virtual void Handle() override
+	{
+		// Validate all entries are strings before running any searches.
+		TArray<FString> QueryStrings;
+		QueryStrings.Reserve(Queries.Array.Num());
+		for (const TSharedPtr<FJsonValue>& QueryVal : Queries.Array)
+		{
+			FString QueryStr;
+			if (!QueryVal->TryGetString(QueryStr))
+			{
+				WingOut::Stdout.Print(TEXT("ERROR: Queries must be an array of strings.\n"));
+				return;
+			}
+			QueryStrings.Add(QueryStr);
+		}
+
+		WingWidgets Widgets;
+		for (const FString& Query : QueryStrings)
+		{
+			WingOut::Stdout.Printf(TEXT("\n=== %s ===\n\n"), *Query);
+			TArray<WingWidgets::Type> Results = Widgets.Search(Query, MaxResults, false);
+			for (const WingWidgets::Type& Entry : Results)
+			{
+				WingOut::Stdout.Printf(TEXT("%s\n"), *Entry.MenuName);
+			}
+
+			if (Results.Num() == 0)
+			{
+				WingOut::Stdout.Print(TEXT("No matching widget types found.\n"));
+			}
+			else if (Results.Num() >= MaxResults)
+			{
+				WingOut::Stdout.Printf(TEXT("WARNING: Reached limit of %d results. You may specify MaxResults.\n"), MaxResults);
+			}
+		}
+	}
+};