unreal-engine-mcp-server 0.5.0 → 0.5.2

package/tests/test-sequence.mjs

@@ -1,7 +1,8 @@
 #!/usr/bin/env node
 /**
- * Sequencer Test Suite (supported actions only)
+ * Comprehensive Sequencer Test Suite
  * Tool: manage_sequence
+ * Coverage: All 31 actions with success, error, and edge cases
  */
 
 import { runToolTests } from './test-runner.mjs';
@@ -10,59 +11,94 @@ const seqPath = '/Game/Cinematics/TC_Seq';
 const copyDir = '/Game/Cinematics/Copies';
 
 const testCases = [
+  // === PRE-CLEANUP ===
+  {
+    scenario: 'Pre-cleanup: Delete existing test sequences',
+    toolName: 'manage_asset',
+    arguments: { action: 'delete', assetPaths: [seqPath, `${copyDir}/TC_Seq_Copy`, `${copyDir}/TC_Seq_Renamed`, '/Game/Cinematics/TC_Cinematic'] },
+    expected: 'success|not_found'
+  },
+
+  // === LIFECYCLE (create, open, duplicate, rename, delete, list) ===
   { scenario: 'Create sequence', toolName: 'manage_sequence', arguments: { action: 'create', name: 'TC_Seq', path: '/Game/Cinematics' }, expected: 'success|Sequence already exists' },
   { scenario: 'Open sequence', toolName: 'manage_sequence', arguments: { action: 'open', path: seqPath }, expected: 'success' },
-  { scenario: 'Add camera (spawn-only fallback ok)', toolName: 'manage_sequence', arguments: { action: 'add_camera', spawnable: true }, expected: 'success' },
-  { scenario: 'Get bindings', toolName: 'manage_sequence', arguments: { action: 'get_bindings', path: seqPath }, expected: 'success - bindings listed' },
-  { scenario: 'Set playback speed', toolName: 'manage_sequence', arguments: { action: 'set_playback_speed', path: seqPath, speed: 1.2 }, expected: 'success' },
-  { scenario: 'Get sequence properties', toolName: 'manage_sequence', arguments: { action: 'get_properties', path: seqPath }, expected: 'success|INVALID_SEQUENCE' },
+  { scenario: 'List sequences', toolName: 'manage_sequence', arguments: { action: 'list', path: '/Game/Cinematics' }, expected: 'success' },
+  { scenario: 'Get sequence properties', toolName: 'manage_sequence', arguments: { action: 'get_properties', path: seqPath }, expected: 'success' },
+  { scenario: 'Set sequence properties', toolName: 'manage_sequence', arguments: { action: 'set_properties', path: seqPath, playbackStart: 0, playbackEnd: 120 }, expected: 'success' },
   { scenario: 'Duplicate sequence', toolName: 'manage_sequence', arguments: { action: 'duplicate', path: seqPath, destinationPath: copyDir, newName: 'TC_Seq_Copy', overwrite: true }, expected: 'success - duplicated' },
   { scenario: 'Rename sequence copy', toolName: 'manage_sequence', arguments: { action: 'rename', path: `${copyDir}/TC_Seq_Copy`, newName: 'TC_Seq_Renamed' }, expected: 'success|Failed to rename' },
-  { scenario: 'Delete sequence copy', toolName: 'manage_sequence', arguments: { action: 'delete', path: `${copyDir}/TC_Seq_Renamed` }, expected: 'success|Failed to delete' },
-  // Real-World Scenario: Cinematic Shot
-  // Setup: Ensure TC_Cube exists for the cinematic
-  { scenario: 'Setup - Spawn Cube for Cinematic', toolName: 'control_actor', arguments: { action: 'spawn', classPath: '/Engine/BasicShapes/Cube', actorName: 'TC_Cube', location: { x: 0, y: 0, z: 0 } }, expected: 'success' },
+
+  // === METADATA ===
+  { scenario: 'Get sequence metadata', toolName: 'manage_sequence', arguments: { action: 'get_metadata', path: seqPath }, expected: 'success' },
+  { scenario: 'Set sequence metadata', toolName: 'manage_sequence', arguments: { action: 'set_metadata', path: seqPath, metadata: { author: 'Test', version: '1.0' } }, expected: 'success' },
+
+  // === BINDINGS (add_camera, add_actor, add_actors, remove_actors, get_bindings, add_spawnable_from_class) ===
+  { scenario: 'Add camera (spawn-only fallback ok)', toolName: 'manage_sequence', arguments: { action: 'add_camera', path: seqPath, spawnable: true }, expected: 'success' },
+  { scenario: 'Get bindings', toolName: 'manage_sequence', arguments: { action: 'get_bindings', path: seqPath }, expected: 'success - bindings listed' },
+
+  // Setup actor for binding tests
+  { scenario: 'Setup - Spawn Cube for Cinematic', toolName: 'control_actor', arguments: { action: 'spawn', classPath: '/Engine/BasicShapes/Cube', actorName: 'TC_SeqCube', location: { x: 0, y: 0, z: 0 } }, expected: 'success' },
+  { scenario: 'Add actor binding', toolName: 'manage_sequence', arguments: { action: 'add_actor', path: seqPath, actorName: 'TC_SeqCube' }, expected: 'success' },
+  { scenario: 'Add spawnable from class', toolName: 'manage_sequence', arguments: { action: 'add_spawnable_from_class', path: seqPath, className: 'PointLight' }, expected: 'success' },
+  { scenario: 'Remove actors', toolName: 'manage_sequence', arguments: { action: 'remove_actors', path: seqPath, actorNames: ['TC_SeqCube'] }, expected: 'success' },
+
+  // === PLAYBACK (play, pause, stop, set_playback_speed) ===
+  { scenario: 'Play sequence', toolName: 'manage_sequence', arguments: { action: 'play', path: seqPath }, expected: 'success' },
+  { scenario: 'Pause sequence', toolName: 'manage_sequence', arguments: { action: 'pause', path: seqPath }, expected: 'success' },
+  { scenario: 'Stop sequence', toolName: 'manage_sequence', arguments: { action: 'stop', path: seqPath }, expected: 'success' },
+  { scenario: 'Set playback speed 1.5x', toolName: 'manage_sequence', arguments: { action: 'set_playback_speed', path: seqPath, speed: 1.5 }, expected: 'success' },
+  { scenario: 'Set playback speed 0.5x', toolName: 'manage_sequence', arguments: { action: 'set_playback_speed', path: seqPath, speed: 0.5 }, expected: 'success' },
+
+  // === KEYFRAMES (add_keyframe) ===
+  { scenario: 'Re-add actor for keyframes', toolName: 'manage_sequence', arguments: { action: 'add_actor', path: seqPath, actorName: 'TC_SeqCube' }, expected: 'success' },
+  { scenario: 'Add keyframe at frame 0', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: seqPath, actorName: 'TC_SeqCube', property: 'Transform', frame: 0, value: { location: { x: 0, y: 0, z: 0 } } }, expected: 'success' },
+  { scenario: 'Add keyframe at frame 60', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: seqPath, actorName: 'TC_SeqCube', property: 'Transform', frame: 60, value: { location: { x: 200, y: 0, z: 0 } } }, expected: 'success' },
+  { scenario: 'Add keyframe at frame 120', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: seqPath, actorName: 'TC_SeqCube', property: 'Transform', frame: 120, value: { location: { x: 0, y: 200, z: 0 } } }, expected: 'success' },
+
+  // === TRACKS (add_track, add_section, list_tracks, remove_track, set_track_muted, set_track_solo, set_track_locked) ===
+  { scenario: 'Add Transform track', toolName: 'manage_sequence', arguments: { action: 'add_track', path: seqPath, actorName: 'TC_SeqCube', trackType: 'Transform' }, expected: 'success' },
+  { scenario: 'Add Event track', toolName: 'manage_sequence', arguments: { action: 'add_track', path: seqPath, actorName: 'TC_SeqCube', trackType: 'Event' }, expected: 'success' },
+  { scenario: 'List tracks', toolName: 'manage_sequence', arguments: { action: 'list_tracks', path: seqPath }, expected: 'success' },
+  { scenario: 'Add section to track', toolName: 'manage_sequence', arguments: { action: 'add_section', path: seqPath, trackName: 'Transform', startFrame: 0, endFrame: 120 }, expected: 'success' },
+  { scenario: 'Set track muted', toolName: 'manage_sequence', arguments: { action: 'set_track_muted', path: seqPath, trackName: 'Transform', muted: true }, expected: 'success' },
+  { scenario: 'Set track unmuted', toolName: 'manage_sequence', arguments: { action: 'set_track_muted', path: seqPath, trackName: 'Transform', muted: false }, expected: 'success' },
+  { scenario: 'Set track solo', toolName: 'manage_sequence', arguments: { action: 'set_track_solo', path: seqPath, trackName: 'Transform', solo: true }, expected: 'success' },
+  { scenario: 'Set track locked', toolName: 'manage_sequence', arguments: { action: 'set_track_locked', path: seqPath, trackName: 'Transform', locked: true }, expected: 'success' },
+  { scenario: 'Set track unlocked', toolName: 'manage_sequence', arguments: { action: 'set_track_locked', path: seqPath, trackName: 'Transform', locked: false }, expected: 'success' },
+
+  // === DISPLAY/TIMING SETTINGS ===
+  { scenario: 'Set display rate 30fps', toolName: 'manage_sequence', arguments: { action: 'set_display_rate', path: seqPath, frameRate: '30fps' }, expected: 'success' },
+  { scenario: 'Set display rate 60fps', toolName: 'manage_sequence', arguments: { action: 'set_display_rate', path: seqPath, frameRate: '60fps' }, expected: 'success' },
+  { scenario: 'Set tick resolution', toolName: 'manage_sequence', arguments: { action: 'set_tick_resolution', path: seqPath, resolution: '24000fps' }, expected: 'success' },
+  { scenario: 'Set work range', toolName: 'manage_sequence', arguments: { action: 'set_work_range', path: seqPath, start: 0, end: 150 }, expected: 'success' },
+  { scenario: 'Set view range', toolName: 'manage_sequence', arguments: { action: 'set_view_range', path: seqPath, start: 0, end: 120 }, expected: 'success' },
+
+  // === REAL-WORLD SCENARIO ===
   { scenario: 'Cinematic - Create Sequence', toolName: 'manage_sequence', arguments: { action: 'create', name: 'TC_Cinematic', path: '/Game/Cinematics' }, expected: 'success|Sequence already exists' },
-  { scenario: 'Cinematic - Add Actor', toolName: 'manage_sequence', arguments: { action: 'add_actor', path: '/Game/Cinematics/TC_Cinematic', actorName: 'TC_Cube' }, expected: 'success' },
-  { scenario: 'Cinematic - Keyframe Transform', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: '/Game/Cinematics/TC_Cinematic', actorName: 'TC_Cube', property: 'Transform', frame: 0, value: { location: { x: 0, y: 0, z: 0 } } }, expected: 'success' },
-  { scenario: 'Cinematic - Keyframe End', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: '/Game/Cinematics/TC_Cinematic', actorName: 'TC_Cube', property: 'Transform', frame: 60, value: { location: { x: 200, y: 0, z: 0 } } }, expected: 'success' },
+  { scenario: 'Cinematic - Add Actor', toolName: 'manage_sequence', arguments: { action: 'add_actor', path: '/Game/Cinematics/TC_Cinematic', actorName: 'TC_SeqCube' }, expected: 'success' },
+  { scenario: 'Cinematic - Keyframe Start', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: '/Game/Cinematics/TC_Cinematic', actorName: 'TC_SeqCube', property: 'Transform', frame: 0, value: { location: { x: 0, y: 0, z: 0 } } }, expected: 'success' },
+  { scenario: 'Cinematic - Keyframe End', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: '/Game/Cinematics/TC_Cinematic', actorName: 'TC_SeqCube', property: 'Transform', frame: 60, value: { location: { x: 200, y: 0, z: 0 } } }, expected: 'success' },
 
-  // Cleanup
+  // === ERROR CASES ===
+  { scenario: 'Error: Invalid actor name', toolName: 'manage_sequence', arguments: { action: 'add_actor', path: seqPath, actorName: 'NonExistentActor' }, expected: 'not_found|error|ASSET_NOT_FOUND|LOAD_FAILED' },
+  { scenario: 'Error: Invalid class spawnable', toolName: 'manage_sequence', arguments: { action: 'add_spawnable_from_class', path: seqPath, className: 'InvalidClass' }, expected: 'error' },
+  { scenario: 'Error: Invalid sequence path', toolName: 'manage_sequence', arguments: { action: 'open', path: '/Game/NonExistent/Sequence' }, expected: 'error|not_found' },
+  { scenario: 'Error: Remove track non-existent', toolName: 'manage_sequence', arguments: { action: 'remove_track', path: seqPath, trackName: 'NonExistentTrack' }, expected: 'error|not_found' },
+
+  // === EDGE CASES ===
+  { scenario: 'Edge: Playback speed 0', toolName: 'manage_sequence', arguments: { action: 'set_playback_speed', speed: 0 }, expected: 'error' },
+  { scenario: 'Edge: Negative frame keyframe', toolName: 'manage_sequence', arguments: { action: 'add_keyframe', path: seqPath, actorName: 'TC_SeqCube', property: 'Transform', frame: -10, value: {} }, expected: 'success|error' },
+  { scenario: 'Edge: Empty actors array', toolName: 'manage_sequence', arguments: { action: 'add_actors', path: seqPath, actorNames: [] }, expected: 'actorNames required|INVALID_ARGUMENT' },
+  { scenario: 'Edge: Very high work range', toolName: 'manage_sequence', arguments: { action: 'set_work_range', path: seqPath, start: 0, end: 100000 }, expected: 'success' },
+
+  // === CLEANUP ===
   { scenario: 'Cleanup - Delete Cinematic', toolName: 'manage_sequence', arguments: { action: 'delete', path: '/Game/Cinematics/TC_Cinematic' }, expected: 'success|Failed to delete' },
-  { scenario: 'Cleanup - Delete Cube', toolName: 'control_actor', arguments: { action: 'delete', actorName: 'TC_Cube' }, expected: 'success' },
+  { scenario: 'Cleanup - Delete Cube', toolName: 'control_actor', arguments: { action: 'delete', actorName: 'TC_SeqCube' }, expected: 'success' },
+  { scenario: 'Cleanup - Remove track', toolName: 'manage_sequence', arguments: { action: 'remove_track', path: seqPath, trackName: 'Event' }, expected: 'success|not_found' },
   { scenario: 'Delete original sequence', toolName: 'manage_sequence', arguments: { action: 'delete', path: seqPath }, expected: 'success|Failed to delete' },
-  { scenario: 'Verify sequence removed', toolName: 'manage_sequence', arguments: { action: 'get_bindings', path: seqPath }, expected: 'success|not found|error|ASSET_NOT_FOUND|LOAD_FAILED' },
-
-  {
-    scenario: "Error: Invalid actor name",
-    toolName: "manage_sequence",
-    arguments: { action: "add_actor", path: seqPath, actorName: "NonExistentActor" },
-    expected: "not_found|error|ASSET_NOT_FOUND|LOAD_FAILED"
-  },
-  {
-    scenario: "Edge: Playback speed 0",
-    toolName: "manage_sequence",
-    arguments: { action: "set_playback_speed", speed: 0 },
-    expected: "error"
-  },
-  {
-    scenario: "Border: Empty actors array",
-    toolName: "manage_sequence",
-    arguments: { action: "add_actors", path: seqPath, actorNames: [] },
-    expected: "actorNames required|INVALID_ARGUMENT"
-  },
-  {
-    scenario: "Error: Invalid class spawnable",
-    toolName: "manage_sequence",
-    arguments: { action: "add_spawnable_from_class", path: seqPath, className: "InvalidClass" },
-    expected: "error"
-  },
-  {
-    scenario: "Cleanup Sequence Tests",
-    toolName: "manage_asset",
-    arguments: { action: "delete", assetPaths: [seqPath] },
-    expected: "success|ASSET_NOT_FOUND|LOAD_FAILED"
-  }
+  { scenario: 'Delete renamed copy', toolName: 'manage_sequence', arguments: { action: 'delete', path: `${copyDir}/TC_Seq_Renamed` }, expected: 'success|Failed to delete' },
+  { scenario: 'Verify sequences removed', toolName: 'manage_sequence', arguments: { action: 'get_bindings', path: seqPath }, expected: 'success|not found|error|ASSET_NOT_FOUND|LOAD_FAILED' },
+  { scenario: 'Final cleanup via manage_asset', toolName: 'manage_asset', arguments: { action: 'delete', assetPaths: [seqPath, copyDir] }, expected: 'success|ASSET_NOT_FOUND|LOAD_FAILED' }
 ];
 
 await runToolTests('Sequences', testCases);

package/tests/test-system.mjs

@@ -1,56 +1,95 @@
 #!/usr/bin/env node
 /**
- * Condensed System Control Test Suite (15 safe cases)
+ * Comprehensive System Control Test Suite
  * Tool: system_control
- * This file avoids destructive operations (engine quit/start) and focuses on
- * safe diagnostics, screenshots, widget operations, CVARs, and profiling toggles.
+ * Coverage: All 22 actions with success, error, and edge cases
  */
 
 import { runToolTests } from './test-runner.mjs';
 
 const testCases = [
+  // === PROFILING (profile, show_fps, show_stats) ===
   { scenario: 'Enable FPS display', toolName: 'system_control', arguments: { action: 'show_fps', enabled: true }, expected: 'success - FPS shown' },
   { scenario: 'Disable FPS display', toolName: 'system_control', arguments: { action: 'show_fps', enabled: false }, expected: 'success - FPS hidden' },
-  { scenario: 'Enable CPU profiling (brief)', toolName: 'system_control', arguments: { action: 'profile', profileType: 'CPU', enabled: true }, expected: 'success - profiling enabled' },
+  { scenario: 'Show stats', toolName: 'system_control', arguments: { action: 'show_stats', category: 'Engine' }, expected: 'success' },
+  { scenario: 'Enable CPU profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'CPU', enabled: true }, expected: 'success - profiling enabled' },
   { scenario: 'Disable CPU profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'CPU', enabled: false }, expected: 'success - profiling disabled' },
+  { scenario: 'Enable GPU profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'GPU', enabled: true }, expected: 'success' },
+  { scenario: 'Disable GPU profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'GPU', enabled: false }, expected: 'success' },
+  { scenario: 'Enable RenderThread profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'RenderThread', enabled: true }, expected: 'success' },
+  { scenario: 'Disable RenderThread profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'RenderThread', enabled: false }, expected: 'success' },
+  { scenario: 'Enable Memory profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'Memory', enabled: true }, expected: 'success' },
+  { scenario: 'Disable Memory profiling', toolName: 'system_control', arguments: { action: 'profile', profileType: 'Memory', enabled: false }, expected: 'success' },
+  { scenario: 'Profile All', toolName: 'system_control', arguments: { action: 'profile', profileType: 'All', enabled: true }, expected: 'success' },
+  { scenario: 'Generate memory report', toolName: 'system_control', arguments: { action: 'profile', profileType: 'Memory', detailed: true, outputPath: './tests/reports' }, expected: 'success' },
+
+  // === QUALITY SETTINGS (set_quality, set_resolution_scale, set_vsync, set_frame_rate_limit) ===
   { scenario: 'Set shadow quality to medium', toolName: 'system_control', arguments: { action: 'set_quality', category: 'Shadow', level: 1 }, expected: 'success - quality set' },
   { scenario: 'Set texture quality to high', toolName: 'system_control', arguments: { action: 'set_quality', category: 'Texture', level: 2 }, expected: 'success - quality set' },
+  { scenario: 'Set quality level 0 (low)', toolName: 'system_control', arguments: { action: 'set_quality', category: 'ViewDistance', level: 0 }, expected: 'success' },
+  { scenario: 'Set quality level 3 (epic)', toolName: 'system_control', arguments: { action: 'set_quality', category: 'Effects', level: 3 }, expected: 'success' },
+
+  // === CONSOLE COMMANDS (execute_command, console_command) ===
   { scenario: 'Execute console command (stat fps)', toolName: 'system_control', arguments: { action: 'execute_command', command: 'stat fps' }, expected: 'success - console command executed' },
+  { scenario: 'Console command (alias)', toolName: 'system_control', arguments: { action: 'console_command', command: 'stat unit' }, expected: 'success' },
+  { scenario: 'Console command - stat none', toolName: 'system_control', arguments: { action: 'console_command', command: 'stat none' }, expected: 'success' },
+  { scenario: 'Console command - gc', toolName: 'system_control', arguments: { action: 'console_command', command: 'obj gc' }, expected: 'success' },
+
+  // === SCREENSHOTS ===
   { scenario: 'Take a screenshot', toolName: 'system_control', arguments: { action: 'screenshot', filename: 'tc_sys_screenshot' }, expected: 'success - screenshot taken' },
   { scenario: 'Take screenshot with metadata', toolName: 'system_control', arguments: { action: 'screenshot', includeMetadata: true, metadata: { test: 'system_tc' } }, expected: 'success - metadata screenshot taken' },
+
+  // === RESOLUTION / DISPLAY ===
+  { scenario: 'Set resolution 1920x1080', toolName: 'system_control', arguments: { action: 'set_resolution', resolution: '1920x1080' }, expected: 'success' },
+  { scenario: 'Set fullscreen on', toolName: 'system_control', arguments: { action: 'set_fullscreen', enabled: true }, expected: 'success' },
+  { scenario: 'Set fullscreen off', toolName: 'system_control', arguments: { action: 'set_fullscreen', enabled: false }, expected: 'success' },
+
+  // === WIDGETS ===
   { scenario: 'Create debug widget asset', toolName: 'system_control', arguments: { action: 'create_widget', name: 'TestWidget_Safe', savePath: '/Game/Tests' }, expected: 'success - widget created or handled' },
-  { scenario: 'Show short notification', toolName: 'system_control', arguments: { action: 'show_widget', widgetId: 'Notification', visible: true, message: 'TC: Notification', duration: 1.5 }, expected: 'success - notification shown' },
+  { scenario: 'Create console widget asset', toolName: 'system_control', arguments: { action: 'create_widget', name: 'TestWidget_Console', savePath: '/Game/Tests' }, expected: 'success - widget created or handled' },
+  { scenario: 'Show notification widget', toolName: 'system_control', arguments: { action: 'show_widget', widgetId: 'Notification', visible: true, message: 'TC: Notification', duration: 1.5 }, expected: 'success - notification shown' },
+  { scenario: 'Add child to widget', toolName: 'system_control', arguments: { action: 'add_widget_child', parentName: 'TestWidget_Safe', childClass: 'Button' }, expected: 'success|handled' },
+
+  // === CVARS ===
   { scenario: 'Set VSync CVAR', toolName: 'system_control', arguments: { action: 'set_cvar', name: 'r.VSync', value: '0' }, expected: 'success - CVAR set' },
   { scenario: 'Set max FPS CVAR', toolName: 'system_control', arguments: { action: 'set_cvar', name: 't.MaxFPS', value: '60' }, expected: 'success - CVAR set' },
-  { scenario: 'Play short UI sound (best-effort)', toolName: 'system_control', arguments: { action: 'play_sound', soundPath: '/Engine/EditorSounds/Notifications/CompileSuccess.CompileSuccess', volume: 0.5 }, expected: 'success - sound played or handled' },
-  { scenario: 'Create console widget asset', toolName: 'system_control', arguments: { action: 'create_widget', name: 'TestWidget_Console', savePath: '/Game/Tests' }, expected: 'success - widget created or handled' },
-  // Additional
-  // Real-World Scenario: Project Validation
-  { scenario: 'Validation - Check Settings', toolName: 'system_control', arguments: { action: 'get_project_settings', category: 'Project' }, expected: 'success' },
-  { scenario: 'Validation - Validate Assets', toolName: 'system_control', arguments: { action: 'validate_assets', paths: ['/Game'] }, expected: 'success' },
-  {
-    scenario: "Error: Invalid profile type",
-    toolName: "system_control",
-    arguments: { action: "profile", profileType: "InvalidProfile" },
-    expected: "error"
-  },
-  {
-    scenario: "Edge: Quality level 0 (low)",
-    toolName: "system_control",
-    arguments: { action: "set_quality", category: "ViewDistance", level: 0 },
-    expected: "success"
-  },
-  {
-    scenario: "Border: Volume 0 (silent)",
-    toolName: "system_control",
-    arguments: { action: "play_sound", soundPath: "/Engine/EditorSounds/Notifications/CompileSuccess.CompileSuccess", volume: 0 },
-    expected: "success"
-  },
+  { scenario: 'Set anti-aliasing CVAR', toolName: 'system_control', arguments: { action: 'set_cvar', name: 'r.PostProcessAAQuality', value: '4' }, expected: 'success' },
+  { scenario: 'Set LOD bias CVAR', toolName: 'system_control', arguments: { action: 'set_cvar', name: 'foliage.LODDistanceScale', value: '1.0' }, expected: 'success' },
+
+  // === SOUND ===
+  { scenario: 'Play UI sound', toolName: 'system_control', arguments: { action: 'play_sound', soundPath: '/Engine/EditorSounds/Notifications/CompileSuccess.CompileSuccess', volume: 0.5 }, expected: 'success - sound played or handled' },
+  { scenario: 'Play sound silent', toolName: 'system_control', arguments: { action: 'play_sound', soundPath: '/Engine/EditorSounds/Notifications/CompileSuccess.CompileSuccess', volume: 0 }, expected: 'success' },
+
+  // === PROJECT SETTINGS ===
+  { scenario: 'Get project settings', toolName: 'system_control', arguments: { action: 'get_project_settings', category: 'Project' }, expected: 'success' },
+  { scenario: 'Get project settings - Engine', toolName: 'system_control', arguments: { action: 'get_project_settings', section: '/Script/EngineSettings.GeneralProjectSettings' }, expected: 'success' },
+  { scenario: 'Set project setting', toolName: 'system_control', arguments: { action: 'set_project_setting', section: '/Script/Engine.Engine', key: 'bSmoothFrameRate', value: 'true', configName: 'Engine' }, expected: 'success|handled' },
+
+  // === VALIDATION ===
+  { scenario: 'Validate assets', toolName: 'system_control', arguments: { action: 'validate_assets', paths: ['/Game'] }, expected: 'success' },
+
+  // === LUMEN ===
+  { scenario: 'Lumen update scene', toolName: 'system_control', arguments: { action: 'lumen_update_scene' }, expected: 'success|handled' },
+
+  // === SUBSCRIPTIONS (subscribe, unsubscribe, spawn_category, start_session) ===
+  { scenario: 'Subscribe to events', toolName: 'system_control', arguments: { action: 'subscribe', channels: 'Assets' }, expected: 'success|handled' },
+  { scenario: 'Unsubscribe from events', toolName: 'system_control', arguments: { action: 'unsubscribe', channels: 'Assets' }, expected: 'success|handled' },
+  { scenario: 'Spawn category', toolName: 'system_control', arguments: { action: 'spawn_category', category: 'TestCategory' }, expected: 'success|handled' },
+  { scenario: 'Start session', toolName: 'system_control', arguments: { action: 'start_session' }, expected: 'success|handled' },
+
+  // === ERROR CASES ===
+  { scenario: 'Error: Invalid profile type', toolName: 'system_control', arguments: { action: 'profile', profileType: 'InvalidProfile' }, expected: 'error' },
+  { scenario: 'Error: Empty command', toolName: 'system_control', arguments: { action: 'console_command', command: '' }, expected: 'error|handled' },
+  { scenario: 'Error: Invalid resolution', toolName: 'system_control', arguments: { action: 'set_resolution', width: -1, height: -1 }, expected: 'error|validation' },
+  { scenario: 'Error: Invalid quality level', toolName: 'system_control', arguments: { action: 'set_quality', category: 'Shadow', level: 999 }, expected: 'error|clamped' },
+  { scenario: 'Error: Invalid sound path', toolName: 'system_control', arguments: { action: 'play_sound', soundPath: '/Game/Invalid/Sound' }, expected: 'error|not_found' },
+
+  // === CLEANUP ===
   {
-    scenario: "Error: Invalid resolution",
-    toolName: "system_control",
-    arguments: { action: "set_resolution", width: -1, height: -1 },
-    expected: "error|validation"
+    scenario: 'Cleanup widgets',
+    toolName: 'manage_asset',
+    arguments: { action: 'delete', assetPaths: ['/Game/Tests/TestWidget_Safe', '/Game/Tests/TestWidget_Console'] },
+    expected: 'success|handled'
   }
 ];
 

package/tests/test-wasm.mjs

@@ -156,16 +156,106 @@ async function testWASMIntegration() {
   log.info('\n=== Performance Report ===');
   log.info(wasmIntegration.reportPerformance());
 
-  // Test 8: Fallback Mechanism
-  log.info('\n=== Test 8: Fallback Mechanism ===');
-  log.info('Testing TypeScript fallback by clearing metrics...');
-  wasmIntegration.clearMetrics();
+  // Test 9: Circular Dependency Detection
+  log.info('\n=== Test 9: Circular Dependency Detection ===');
+  const circularDeps = {
+    'AssetA': ['AssetB'],
+    'AssetB': ['AssetC'],
+    'AssetC': ['AssetA'] // Creates a cycle
+  };
+
+  try {
+    const circular = await wasmIntegration.findCircularDependencies(circularDeps);
+    log.info(`✅ Circular dependency detection completed`);
+    log.info(`Found ${circular.length} circular dependency chains`);
+    if (circular.length > 0) {
+      log.info(`Cycle: ${circular[0].join(' -> ')}`);
+    }
+  } catch (error) {
+    log.error('❌ Circular dependency detection failed:', error.message);
+  }
+
+  // Test 10: Topological Sort
+  log.info('\n=== Test 10: Topological Sort ===');
+  const sortDeps = {
+    'D': [],
+    'C': ['D'],
+    'B': ['C', 'D'],
+    'A': ['B', 'C']
+  };
+
+  try {
+    const sorted = await wasmIntegration.topologicalSort(sortDeps);
+    log.info(`✅ Topological sort completed`);
+    log.info(`Order: ${sorted.join(' -> ')}`);
+    // D should come before C, C before B, B before A
+    const dIdx = sorted.indexOf('D');
+    const cIdx = sorted.indexOf('C');
+    const bIdx = sorted.indexOf('B');
+    const aIdx = sorted.indexOf('A');
+    if (dIdx < cIdx && cIdx < bIdx && bIdx < aIdx) {
+      log.info('✅ Sort order is correct');
+    } else {
+      log.warn('⚠️ Sort order may be incorrect');
+    }
+  } catch (error) {
+    log.error('❌ Topological sort failed:', error.message);
+  }
 
-  // Force a few operations to test metrics
-  await wasmIntegration.parseProperties(testJson);
-  const newMetrics = wasmIntegration.getMetrics();
+  // Test 11: Edge Cases
+  log.info('\n=== Test 11: Edge Cases ===');
 
-  log.info(`✅ Metrics reset successful (${newMetrics.totalOperations} operations)`);
+  // Empty JSON
+  try {
+    const emptyResult = await wasmIntegration.parseProperties('{}');
+    log.info(`✅ Empty JSON parsing: ${Object.keys(emptyResult).length === 0 ? 'passed' : 'result has keys'}`);
+  } catch (error) {
+    log.error('❌ Empty JSON parsing failed:', error.message);
+  }
+
+  // Invalid JSON (should fallback gracefully)
+  try {
+    await wasmIntegration.parseProperties('not valid json');
+    log.warn('⚠️ Invalid JSON did not throw - fallback handled');
+  } catch (error) {
+    log.info(`✅ Invalid JSON correctly rejected: ${error.message.substring(0, 50)}...`);
+  }
+
+  // Zero vectors
+  try {
+    const zeroAdd = wasmIntegration.vectorAdd([0, 0, 0], [0, 0, 0]);
+    const isZero = zeroAdd.every(v => v === 0);
+    log.info(`✅ Zero vector addition: ${isZero ? 'passed' : 'unexpected result'}`);
+  } catch (error) {
+    log.error('❌ Zero vector test failed:', error.message);
+  }
+
+  // Test 12: Performance Benchmark
+  log.info('\n=== Test 12: Performance Benchmark ===');
+  const iterations = 100;
+  const largeJson = JSON.stringify({
+    assets: Array.from({ length: 50 }, (_, i) => ({
+      name: `Asset${i}`,
+      path: `/Game/Assets/Asset${i}`,
+      properties: { value: i * 100, enabled: i % 2 === 0 }
+    }))
+  });
+
+  const benchStart = performance.now();
+  for (let i = 0; i < iterations; i++) {
+    await wasmIntegration.parseProperties(largeJson);
+  }
+  const benchDuration = performance.now() - benchStart;
+  log.info(`✅ Parsed ${iterations} large JSON objects in ${benchDuration.toFixed(2)}ms`);
+  log.info(`Average: ${(benchDuration / iterations).toFixed(3)}ms per parse`);
+
+  // Vector math benchmark
+  const vecStart = performance.now();
+  for (let i = 0; i < 1000; i++) {
+    wasmIntegration.vectorAdd([i, i + 1, i + 2], [i * 2, i * 3, i * 4]);
+  }
+  const vecDuration = performance.now() - vecStart;
+  log.info(`✅ 1000 vector additions in ${vecDuration.toFixed(2)}ms`);
 
   // Final Summary
   log.info('\n=== Test Summary ===');

package/vitest.config.ts

@@ -0,0 +1,35 @@
+import { defineConfig } from 'vitest/config';
+
+export default defineConfig({
+    test: {
+        globals: true,
+        environment: 'node',
+        include: [
+            'src/**/*.test.ts',
+            'tests/unit/**/*.test.ts'
+        ],
+        exclude: [
+            '**/node_modules/**',
+            '**/dist/**'
+        ],
+        coverage: {
+            provider: 'v8',
+            reporter: ['text', 'text-summary', 'html'],
+            include: ['src/**/*.ts'],
+            exclude: [
+                'src/**/*.test.ts',
+                'src/types/**',
+                'src/**/*.d.ts'
+            ],
+            thresholds: {
+                // Start with low thresholds, increase as coverage improves
+                lines: 20,
+                functions: 20,
+                branches: 20,
+                statements: 20
+            }
+        },
+        testTimeout: 10000,
+        hookTimeout: 10000
+    }
+});

package/.github/release-drafter.yml

@@ -1,148 +0,0 @@
-name: Release Drafter
-
-on:
-  push:
-    branches:
-      - main
-  workflow_dispatch:
-
-permissions:
-  contents: read
-
-jobs:
-  update_release_draft:
-    permissions:
-      contents: write
-      pull-requests: write
-    runs-on: ubuntu-latest
-    steps:
-      - name: Checkout
-        uses: actions/checkout@v4
-        with:
-          fetch-depth: 0
-
-      - name: Run Release Drafter
-        id: release_drafter
-        uses: release-drafter/release-drafter@v6
-        with:
-          config-name: release-drafter.yml
-        env:
-          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
-
-      - name: Get commits not in PRs
-        id: orphan_commits
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            const { execSync } = require('child_process');
-            
-            // Get the last release tag
-            let lastTag;
-            try {
-              const { data: releases } = await github.rest.repos.listReleases({
-                owner: context.repo.owner,
-                repo: context.repo.repo,
-                per_page: 1
-              });
-              lastTag = releases[0]?.tag_name;
-            } catch (e) {
-              lastTag = null;
-            }
-            
-            // Get all commits since last release
-            const range = lastTag ? `${lastTag}..HEAD` : 'HEAD~50..HEAD';
-            let commits;
-            try {
-              commits = execSync(`git log ${range} --pretty=format:"%H|%s|%an" --no-merges`, { encoding: 'utf-8' })
-                .split('\n')
-                .filter(Boolean)
-                .map(line => {
-                  const [sha, message, author] = line.split('|');
-                  return { sha, message, author };
-                });
-            } catch (e) {
-              commits = [];
-            }
-            
-            if (commits.length === 0) {
-              core.setOutput('orphan_commits', '');
-              return;
-            }
-            
-            // Get all PRs merged since last release to filter out PR commits
-            const { data: prs } = await github.rest.pulls.list({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              state: 'closed',
-              sort: 'updated',
-              direction: 'desc',
-              per_page: 100
-            });
-            
-            // Get commit SHAs that are part of PRs
-            const prCommitShas = new Set();
-            for (const pr of prs.filter(p => p.merged_at)) {
-              try {
-                const { data: prCommits } = await github.rest.pulls.listCommits({
-                  owner: context.repo.owner,
-                  repo: context.repo.repo,
-                  pull_number: pr.number
-                });
-                prCommits.forEach(c => prCommitShas.add(c.sha));
-              } catch (e) {
-                // Skip if error
-              }
-            }
-            
-            // Filter to only orphan commits (not in any PR)
-            const orphanCommits = commits.filter(c => !prCommitShas.has(c.sha));
-            
-            if (orphanCommits.length === 0) {
-              core.setOutput('orphan_commits', '');
-              return;
-            }
-            
-            // Format orphan commits
-            const formatted = orphanCommits
-              .map(c => `- ${c.message} (${c.sha.substring(0, 7)}) @${c.author}`)
-              .join('\n');
-            
-            core.setOutput('orphan_commits', formatted);
-            core.info(`Found ${orphanCommits.length} commits not in PRs`);
-
-      - name: Update release body with commits
-        if: steps.orphan_commits.outputs.orphan_commits != ''
-        uses: actions/github-script@v7
-        with:
-          github-token: ${{ secrets.GITHUB_TOKEN }}
-          script: |
-            const releaseId = '${{ steps.release_drafter.outputs.id }}';
-            const orphanCommits = `${{ steps.orphan_commits.outputs.orphan_commits }}`;
-            
-            if (!releaseId || !orphanCommits) return;
-            
-            // Get current release body
-            const { data: release } = await github.rest.repos.getRelease({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              release_id: parseInt(releaseId)
-            });
-            
-            // Check if commits section already exists
-            if (release.body && release.body.includes('## Direct Commits')) {
-              core.info('Commits section already exists, skipping');
-              return;
-            }
-            
-            // Append commits section
-            const newBody = `${release.body || ''}\n\n## Direct Commits\n\n${orphanCommits}`;
-            
-            await github.rest.repos.updateRelease({
-              owner: context.repo.owner,
-              repo: context.repo.repo,
-              release_id: parseInt(releaseId),
-              body: newBody
-            });
-            
-            core.info('Added orphan commits to release draft');

package/dist/prompts/index.d.ts

@@ -1,21 +0,0 @@
-export interface PromptArgument {
-    type: string;
-    description?: string;
-    enum?: string[];
-    default?: unknown;
-    required?: boolean;
-}
-export interface PromptTemplate {
-    name: string;
-    description: string;
-    arguments?: Record<string, PromptArgument>;
-    build: (args: Record<string, unknown>) => Array<{
-        role: 'user' | 'assistant';
-        content: {
-            type: 'text';
-            text: string;
-        };
-    }>;
-}
-export declare const prompts: PromptTemplate[];
-//# sourceMappingURL=index.d.ts.map