blueprint-extractor-mcp 1.4.1 → 1.6.0

package/dist/compactor.js

@@ -16,11 +16,17 @@ export function compactBlueprint(data) {
     const bp = root.blueprint;
     if (!bp)
         return data;
+    // Branch 1: Compact graphs (if present)
     const functions = bp.functions;
-    if (!Array.isArray(functions))
-        return data;
-    for (const graph of functions) {
-        compactGraph(graph);
+    if (Array.isArray(functions)) {
+        for (const graph of functions) {
+            compactGraph(graph);
+        }
+    }
+    // Branch 2: Compact widget tree (if present)
+    const wt = bp.widgetTree;
+    if (wt && typeof wt === 'object' && wt.rootWidget) {
+        compactWidgetNode(wt.rootWidget);
     }
     return data;
 }
@@ -60,6 +66,29 @@ function compactGraph(graph) {
         }
     }
 }
+function compactWidgetNode(node) {
+    if (!node)
+        return;
+    // Remove displayLabel when it equals name or is empty (redundant)
+    if (node.displayLabel === node.name || node.displayLabel === '') {
+        delete node.displayLabel;
+    }
+    // Remove default visibility
+    if (node.visibility === 'Visible') {
+        delete node.visibility;
+    }
+    // Remove empty properties objects
+    if (node.properties && typeof node.properties === 'object' && Object.keys(node.properties).length === 0) {
+        delete node.properties;
+    }
+    // Recurse into children
+    const children = node.children;
+    if (Array.isArray(children)) {
+        for (const child of children) {
+            compactWidgetNode(child);
+        }
+    }
+}
 function compactPin(pin, guidToShortId) {
     // Remove pinId
     delete pin.pinId;

package/dist/index.js

@@ -7,7 +7,7 @@ import { compactBlueprint } from './compactor.js';
 const client = new UEClient();
 const server = new McpServer({
     name: 'blueprint-extractor',
-    version: '1.4.0',
+    version: '1.6.0',
 });
 // Shared scope enum with detailed descriptions
 const scopeEnum = z.enum([
@@ -34,7 +34,7 @@ server.resource('extraction-scopes', 'blueprint://scopes', {
                 '|-------------------|---------------------------------------------------|---------------|-----------------------------------------------|',
                 '| ClassLevel        | Parent class, interfaces, class flags, metadata   | 1-2 KB        | Checking inheritance or interface list         |',
                 '| Variables         | All variables with types, defaults, flags          | 2-10 KB       | Understanding data model (DEFAULT)             |',
-                '| Components        | SCS component tree with property overrides vs CDO  | 5-20 KB       | Analyzing component composition                |',
+                '| Components        | SCS component tree with property overrides vs CDO. For WidgetBlueprints: widget tree hierarchy with layout and bindings  | 5-20 KB       | Analyzing component composition                |',
                 '| FunctionsShallow  | Function and event graph names only                | 5-25 KB       | Listing available functions before deep dive   |',
                 '| Full              | Complete graph nodes, pins, and connections         | 20-500+ KB    | Understanding graph logic and execution flow   |',
                 '| FullWithBytecode  | Raw bytecode hex dump per function                 | Largest        | Low-level analysis (rarely needed)             |',
@@ -57,7 +57,7 @@ USAGE GUIDELINES:
 - Start with the narrowest scope that answers your question — each level includes everything from the previous:
   * ClassLevel — parent class, interfaces, class flags, metadata (~1-2KB)
   * Variables — + all variables with types, defaults, flags (~2-10KB)
-  * Components — + SCS component tree with property overrides (~5-20KB)
+  * Components — + SCS component tree with property overrides (~5-20KB). For WidgetBlueprints, also includes the widget tree hierarchy with bindings.
   * FunctionsShallow — + function/event graph names only (~5-25KB)
   * Full — + complete graph nodes, pins, and connections (~20-500KB+)
   * FullWithBytecode — + raw bytecode hex dump (largest, rarely needed)
@@ -294,7 +294,9 @@ server.registerTool('list_assets', {
     title: 'List Assets',
     description: `List UE5 assets under a package path. Use this to browse directory contents when you don't know asset names. If you know (part of) the asset name, prefer search_assets instead — it's faster and doesn't require knowing the directory.
 
-RETURNS: JSON array of objects with path, name, and class for each asset in the directory.`,
+When recursive=false, subdirectories are included in the results with class "Folder" — use this to browse the content tree structure.
+
+RETURNS: JSON array of objects with path, name, and class for each asset (and subfolder when non-recursive) in the directory.`,
     inputSchema: {
         package_path: z.string().describe('UE package path to list (e.g. /Game/Blueprints, /Game/AI). Use /Game to list from the Content root.'),
         recursive: z.boolean().default(true).describe('Whether to include assets in subdirectories.'),
@@ -324,6 +326,160 @@ RETURNS: JSON array of objects with path, name, and class for each asset in the
         return { content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
     }
 });
+// Recursive schema for widget tree nodes (used by build_widget_tree)
+const WidgetNodeSchema = z.lazy(() => z.object({
+    class: z.string().describe('Widget class name (e.g. CanvasPanel, TextBlock, CommonButtonBase, VerticalBox)'),
+    name: z.string().describe('Widget instance name (used for BindWidget matching)'),
+    is_variable: z.boolean().default(false).describe('Mark as variable for BindWidget access from C++'),
+    slot: z.record(z.string(), z.unknown()).optional().describe('Slot properties (type depends on parent panel)'),
+    properties: z.record(z.string(), z.unknown()).optional().describe('Widget UPROPERTY values to set'),
+    children: z.array(WidgetNodeSchema).optional().describe('Child widgets (only valid for panel widgets)'),
+}));
+// Tool 8: create_widget_blueprint
+server.registerTool('create_widget_blueprint', {
+    title: 'Create Widget Blueprint',
+    description: `Create a new UE5 WidgetBlueprint asset with a specified parent class.
+
+USAGE: Provide the content path where the asset should be created and optionally a parent class.
+Default parent is UserWidget. For CommonUI widgets use CommonActivatableWidget, CommonButtonBase, etc.
+
+RETURNS: JSON with success status, asset path, and parent class name.`,
+    inputSchema: {
+        asset_path: z.string().describe('UE content path for the new WidgetBlueprint (e.g. /Game/UI/WBP_MyWidget)'),
+        parent_class: z.string().default('UserWidget').describe('Parent class name (e.g. UserWidget, CommonActivatableWidget, CommonButtonBase)'),
+    },
+    annotations: {
+        title: 'Create Widget Blueprint',
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ asset_path, parent_class }) => {
+    try {
+        const result = await client.callSubsystem('CreateWidgetBlueprint', {
+            AssetPath: asset_path,
+            ParentClass: parent_class,
+        });
+        const parsed = JSON.parse(result);
+        if (parsed.error) {
+            return { content: [{ type: 'text', text: `Error: ${parsed.error}` }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(parsed, null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
+    }
+});
+// Tool 9: build_widget_tree
+server.registerTool('build_widget_tree', {
+    title: 'Build Widget Tree',
+    description: `Build or replace the entire widget hierarchy of an existing WidgetBlueprint from a JSON tree description.
+
+WARNING: This REPLACES the existing widget tree — all current widgets will be removed.
+
+USAGE: Provide the asset path and a root_widget object describing the full tree recursively.
+Each widget node has: class, name, is_variable, slot (optional), properties (optional), children (optional).
+
+RETURNS: JSON with success status, widget count, and any errors.`,
+    inputSchema: {
+        asset_path: z.string().describe('UE content path to an existing WidgetBlueprint'),
+        root_widget: WidgetNodeSchema.describe('Root widget of the tree hierarchy'),
+    },
+    annotations: {
+        title: 'Build Widget Tree',
+        readOnlyHint: false,
+        destructiveHint: true,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ asset_path, root_widget }) => {
+    try {
+        const result = await client.callSubsystem('BuildWidgetTree', {
+            AssetPath: asset_path,
+            WidgetTreeJson: JSON.stringify(root_widget),
+        });
+        const parsed = JSON.parse(result);
+        if (parsed.error) {
+            return { content: [{ type: 'text', text: `Error: ${parsed.error}` }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(parsed, null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
+    }
+});
+// Tool 10: modify_widget
+server.registerTool('modify_widget', {
+    title: 'Modify Widget',
+    description: `Modify properties and/or slot configuration of an existing widget within a WidgetBlueprint.
+
+USAGE: Specify the asset path, widget name, and the properties/slot values to change.
+Only specified properties are modified — others remain unchanged.
+
+RETURNS: JSON with success status, widget name, class, and any errors.`,
+    inputSchema: {
+        asset_path: z.string().describe('UE content path to the WidgetBlueprint'),
+        widget_name: z.string().describe('Name of the widget to modify (as shown in the widget tree)'),
+        properties: z.record(z.string(), z.unknown()).optional().describe('Widget UPROPERTY values to set'),
+        slot: z.record(z.string(), z.unknown()).optional().describe('Slot properties to set'),
+    },
+    annotations: {
+        title: 'Modify Widget',
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ asset_path, widget_name, properties, slot }) => {
+    try {
+        const result = await client.callSubsystem('ModifyWidget', {
+            AssetPath: asset_path,
+            WidgetName: widget_name,
+            PropertiesJson: JSON.stringify(properties ?? {}),
+            SlotJson: JSON.stringify(slot ?? {}),
+        });
+        const parsed = JSON.parse(result);
+        if (parsed.error) {
+            return { content: [{ type: 'text', text: `Error: ${parsed.error}` }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(parsed, null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
+    }
+});
+// Tool 11: compile_widget_blueprint
+server.registerTool('compile_widget_blueprint', {
+    title: 'Compile Widget Blueprint',
+    description: `Compile a WidgetBlueprint and return any errors or warnings.
+
+USAGE: Call after building or modifying a widget tree to verify compilation.
+
+RETURNS: JSON with success status, compilation status, error count, warning count, and error details.`,
+    inputSchema: {
+        asset_path: z.string().describe('UE content path to the WidgetBlueprint to compile'),
+    },
+    annotations: {
+        title: 'Compile Widget Blueprint',
+        readOnlyHint: false,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ asset_path }) => {
+    try {
+        const result = await client.callSubsystem('CompileWidgetBlueprint', { AssetPath: asset_path });
+        const parsed = JSON.parse(result);
+        if (parsed.error) {
+            return { content: [{ type: 'text', text: `Error: ${parsed.error}` }], isError: true };
+        }
+        return { content: [{ type: 'text', text: JSON.stringify(parsed, null, 2) }] };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
+    }
+});
 // Start server
 async function main() {
     const transport = new StdioServerTransport();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blueprint-extractor-mcp",
-  "version": "1.4.1",
+  "version": "1.6.0",
   "description": "MCP server for UE5 BlueprintExtractor plugin",
   "type": "module",
   "main": "dist/index.js",