blueprint-extractor-mcp 1.1.0 → 1.3.0

package/dist/index.js

@@ -6,7 +6,7 @@ import { UEClient } from './ue-client.js';
 const client = new UEClient();
 const server = new McpServer({
     name: 'blueprint-extractor',
-    version: '1.1.0',
+    version: '1.3.0',
 });
 // Shared scope enum with detailed descriptions
 const scopeEnum = z.enum([
@@ -17,6 +17,35 @@ const scopeEnum = z.enum([
     'Full',
     'FullWithBytecode',
 ]);
+// Resource: extraction scope reference (static docs — app-controlled read-only context)
+server.resource('extraction-scopes', 'blueprint://scopes', {
+    description: 'Reference for Blueprint extraction scopes: what each level includes, typical sizes, and when to use.',
+}, async (uri) => ({
+    contents: [{
+            uri: uri.href,
+            mimeType: 'text/plain',
+            text: [
+                'Blueprint Extraction Scopes',
+                '',
+                'Each scope includes everything from the previous level:',
+                '',
+                '| Scope             | Adds                                              | Typical Size  | Use When                                      |',
+                '|-------------------|---------------------------------------------------|---------------|-----------------------------------------------|',
+                '| 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                |',
+                '| 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)             |',
+                '',
+                'Start with the narrowest scope that answers your question.',
+                'Full scope on complex Blueprints can exceed 200KB and will be truncated.',
+                '',
+                'Note: Scopes only apply to Blueprint extraction (extract_blueprint and extract_cascade).',
+                'DataAsset, DataTable, and StateTree always extract fully — no scope parameter is needed.',
+            ].join('\n'),
+        }],
+}));
 // Tool 1: extract_blueprint
 server.registerTool('extract_blueprint', {
     title: 'Extract Blueprint',
@@ -97,10 +126,82 @@ RETURNS: JSON object with schema, state hierarchy, tasks, conditions, transition
         return { content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
     }
 });
-// Tool 3: extract_cascade
+// Tool 3: extract_dataasset
+server.registerTool('extract_dataasset', {
+    title: 'Extract DataAsset',
+    description: `Extract a UE5 DataAsset to structured JSON. Serializes all user-defined UPROPERTY fields using UE reflection.
+
+USAGE GUIDELINES:
+- Use search_assets first with class_filter "DataAsset" or a specific DataAsset subclass name to find the asset path.
+- Returns all user-defined properties with their types and current values.
+- Works with any UDataAsset or UPrimaryDataAsset subclass.
+
+RETURNS: JSON object with the DataAsset's class info and all property values.`,
+    inputSchema: {
+        asset_path: z.string().describe('UE content path to the DataAsset (e.g. /Game/Data/DA_ItemDatabase). Use search_assets to find paths.'),
+    },
+    annotations: {
+        title: 'Extract DataAsset',
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ asset_path }) => {
+    try {
+        const result = await client.callSubsystem('ExtractDataAsset', { 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 };
+    }
+});
+// Tool 4: extract_datatable
+server.registerTool('extract_datatable', {
+    title: 'Extract DataTable',
+    description: `Extract a UE5 DataTable asset to structured JSON. Includes the row struct schema and all row data.
+
+USAGE GUIDELINES:
+- Use search_assets first with class_filter "DataTable" to find the asset path.
+- Returns the row struct type, property schema, row count, and all row data with names and values.
+- Useful for understanding game data tables (items, abilities, stats, etc.).
+
+RETURNS: JSON object with row struct info, schema, and all rows.`,
+    inputSchema: {
+        asset_path: z.string().describe('UE content path to the DataTable (e.g. /Game/Data/DT_WeaponStats). Use search_assets to find paths.'),
+    },
+    annotations: {
+        title: 'Extract DataTable',
+        readOnlyHint: true,
+        destructiveHint: false,
+        idempotentHint: true,
+        openWorldHint: false,
+    },
+}, async ({ asset_path }) => {
+    try {
+        const result = await client.callSubsystem('ExtractDataTable', { AssetPath: asset_path });
+        const parsed = JSON.parse(result);
+        if (parsed.error) {
+            return { content: [{ type: 'text', text: `Error: ${parsed.error}` }], isError: true };
+        }
+        const text = JSON.stringify(parsed, null, 2);
+        if (text.length > 200_000) {
+            return { content: [{ type: 'text', text: `Warning: Response is ${(text.length / 1024).toFixed(0)}KB — large DataTable.\n\n${text.substring(0, 200_000)}...\n[TRUNCATED]` }] };
+        }
+        return { content: [{ type: 'text', text }] };
+    }
+    catch (e) {
+        return { content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
+    }
+});
+// Tool 5: extract_cascade
 server.registerTool('extract_cascade', {
     title: 'Extract Cascade',
-    description: `Extract multiple Blueprint/StateTree assets with automatic reference following. Follows parent classes, interfaces, component classes, and other Blueprint references up to max_depth levels deep.
+    description: `Extract multiple assets (Blueprint, AnimBlueprint, StateTree, DataAsset, DataTable) with automatic reference following for Blueprints and StateTrees. Follows parent classes, interfaces, component classes, and other Blueprint references up to max_depth levels deep.
 
 USAGE GUIDELINES:
 - Use when you need to understand an asset AND its dependencies (parent Blueprints, referenced Blueprints, etc.).
@@ -138,20 +239,20 @@ RETURNS: Summary with extracted_count and output_directory path. Read the output
         return { content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
     }
 });
-// Tool 4: search_assets
+// Tool 6: search_assets
 server.registerTool('search_assets', {
     title: 'Search Assets',
-    description: `Search for UE5 assets by name. This is a lightweight lookup — use it FIRST to find correct asset paths before calling extract_blueprint or extract_statetree.
+    description: `Search for UE5 assets by name. This is a lightweight lookup — use it FIRST to find correct asset paths before calling extract_blueprint, extract_statetree, extract_dataasset, or extract_datatable.
 
 USAGE GUIDELINES:
-- Always call this before extract_blueprint/extract_statetree if you don't already have the exact asset path.
+- Always call this before any extract_* tool if you don't already have the exact asset path.
 - Searches asset names (not full paths) — partial matches work (e.g. "Character" finds "BP_Character").
-- Filter by class to narrow results: "Blueprint" (default), "StateTree", "WidgetBlueprint", "DataAsset", or empty string for all.
+- Filter by class to narrow results: "Blueprint" (default), "AnimBlueprint", "StateTree", "DataTable", "WidgetBlueprint", "DataAsset", or empty string for all.
 
 RETURNS: JSON array of objects with path, name, and class for each matching asset.`,
     inputSchema: {
         query: z.string().describe('Search term to match against asset names. Partial matches work (e.g. "Player" finds "BP_PlayerCharacter").'),
-        class_filter: z.string().default('Blueprint').describe('Filter by asset class. Common values: "Blueprint", "WidgetBlueprint", "StateTree", "DataAsset", or "" for all asset types.'),
+        class_filter: z.string().default('Blueprint').describe('Filter by asset class. Common values: "Blueprint", "AnimBlueprint", "WidgetBlueprint", "StateTree", "DataTable", "DataAsset", or "" for all asset types.'),
     },
     annotations: {
         title: 'Search Assets',
@@ -173,7 +274,7 @@ RETURNS: JSON array of objects with path, name, and class for each matching asse
         return { content: [{ type: 'text', text: `Error: ${e instanceof Error ? e.message : String(e)}` }], isError: true };
     }
 });
-// Tool 5: list_assets
+// Tool 7: list_assets
 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.

package/package.json

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