unreal-engine-mcp-server 0.4.7 → 0.5.0

package/tests/test-materials.mjs

@@ -0,0 +1,356 @@
+#!/usr/bin/env node
+/**
+ * Condensed Materials Test Suite (15 cases) — minimal safe operations.
+ * Tool: manage_asset
+ */
+
+import { runToolTests } from './test-runner.mjs';
+
+const testCases = [
+  {
+    scenario: "Create base material",
+    toolName: "manage_asset",
+    arguments: {
+      action: "create_material",
+      name: "M_BaseMaterial_TC",
+      path: "/Game/Materials"
+    },
+    expected: "success - material created"
+  },
+  {
+    scenario: "Create master material",
+    toolName: "manage_asset",
+    arguments: {
+      action: "create_material",
+      name: "M_MasterMaterial_TC",
+      path: "/Game/Materials",
+      materialType: "Master"
+    },
+    expected: "success - master material created"
+  },
+  {
+    scenario: "Create material instance",
+    toolName: "manage_asset",
+    arguments: {
+      action: "create_material_instance",
+      name: "MI_TestInstance_TC",
+      path: "/Game/Materials",
+      parentMaterial: "/Game/Materials/M_MasterMaterial_TC",
+      parameters: {
+        BaseColor: [0.8, 0.2, 0.2, 1.0]
+      }
+    },
+    expected: "success - material instance created"
+  },
+  {
+    scenario: "List materials folder",
+    toolName: "manage_asset",
+    arguments: {
+      action: "list",
+      directory: "/Game/Materials"
+    },
+    expected: "success - materials listed"
+  },
+  {
+    scenario: "Duplicate material instance",
+    toolName: "manage_asset",
+    arguments: {
+      action: "duplicate",
+      sourcePath: "/Game/Materials/MI_TestInstance_TC",
+      destinationPath: "/Game/Materials/Copies",
+      newName: "MI_TestInstance_Copy_TC",
+      save: true
+    },
+    expected: "success - duplicated"
+  },
+  {
+    scenario: "Rename duplicated material",
+    toolName: "manage_asset",
+    arguments: {
+      action: "rename",
+      assetPath: "/Game/Materials/Copies/MI_TestInstance_Copy_TC",
+      newName: "MI_TestInstance_Renamed_TC"
+    },
+    expected: "success - renamed"
+  },
+  {
+    scenario: "Get dependencies",
+    toolName: "manage_asset",
+    arguments: {
+      action: "get_dependencies",
+      assetPath: "/Game/Materials/MI_TestInstance_TC"
+    },
+    expected: "success - dependencies returned"
+  },
+  {
+    scenario: "Create thumbnail",
+    toolName: "manage_asset",
+    arguments: {
+      action: "create_thumbnail",
+      assetPath: "/Game/Materials/M_BaseMaterial_TC"
+    },
+    expected: "success - thumbnail created"
+  },
+  {
+    scenario: "Set tags",
+    toolName: "manage_asset",
+    arguments: {
+      action: "set_tags",
+      assetPath: "/Game/Materials/M_BaseMaterial_TC",
+      tags: ["TC", "Material"]
+    },
+    expected: "success - tags set"
+  },
+  /*
+  {
+    scenario: "Validate asset",
+    toolName: "manage_asset",
+    arguments: {
+      action: "validate",
+      assetPath: "/Game/Materials/M_BaseMaterial_TC"
+    },
+    expected: "success - asset validated"
+  },
+  {
+    scenario: "Generate small report",
+    toolName: "manage_asset",
+    arguments: {
+      action: "generate_report",
+      directory: "/Game/Materials",
+      reportType: "Size",
+      outputPath: "./tests/reports/materials_report_tc.json"
+    },
+    expected: "success - report generated"
+  },
+  */
+  {
+    scenario: "Move material to subfolder",
+    toolName: "manage_asset",
+    arguments: {
+      action: "move",
+      assetPath: "/Game/Materials/M_BaseMaterial_TC",
+      destinationPath: "/Game/Materials/TC"
+    },
+    expected: "success - moved"
+  },
+  {
+    scenario: "Delete duplicated assets",
+    toolName: "manage_asset",
+    arguments: {
+      action: "delete",
+      assetPaths: [
+        "/Game/Materials/Copies/MI_TestInstance_Renamed_TC"
+      ]
+    },
+    expected: "success - deleted"
+  },
+
+  {
+    scenario: "Remove materials folder",
+    toolName: "manage_asset",
+    arguments: {
+      action: "delete",
+      assetPath: "/Game/Materials/TC"
+    },
+    expected: "success - folder removed"
+  },
+  {
+    scenario: "Inheritance Chain - Create Master",
+    toolName: "manage_asset",
+    arguments: {
+      action: "create_material",
+      name: "M_Chain_Master",
+      path: "/Game/Materials/Chain",
+      materialType: "Master"
+    },
+    expected: "success"
+  },
+  {
+    scenario: "Inheritance Chain - Create Child A",
+    toolName: "manage_asset",
+    arguments: {
+      action: "create_material_instance",
+      name: "MI_Chain_A",
+      path: "/Game/Materials/Chain",
+      parentMaterial: "/Game/Materials/Chain/M_Chain_Master",
+      parameters: {
+        BaseColor: [1.0, 0.0, 0.0, 1.0]
+      }
+    },
+    expected: "success"
+  },
+  {
+    scenario: "Inheritance Chain - Create Child B (Grandchild)",
+    toolName: "manage_asset",
+    arguments: {
+      action: "create_material_instance",
+      name: "MI_Chain_B",
+      path: "/Game/Materials/Chain",
+      parentMaterial: "/Game/Materials/Chain/MI_Chain_A",
+      parameters: {
+        BaseColor: [0.0, 1.0, 0.0, 1.0]
+      }
+    },
+    expected: "success"
+  },
+  {
+    scenario: "Inheritance Chain - Verify Dependencies",
+    toolName: "manage_asset",
+    arguments: {
+      action: "get_dependencies",
+      assetPath: "/Game/Materials/Chain/MI_Chain_B"
+    },
+    expected: "success"
+  },
+  {
+    scenario: "Cleanup Inheritance Chain",
+    toolName: "manage_asset",
+    arguments: {
+      action: "delete",
+      assetPaths: [
+        "/Game/Materials/Chain"
+      ]
+    },
+    expected: "success"
+  },
+  {
+    scenario: "Error: Invalid parent material",
+    toolName: "manage_asset",
+    arguments: { action: "create_material_instance", name: "TestMI", path: "/Game/Test", parentMaterial: "/Invalid/Parent" },
+    expected: "not_found"
+  },
+  {
+    scenario: "Edge: Empty parameters object",
+    toolName: "manage_asset",
+    arguments: { action: "create_material_instance", name: "Test", path: "/Game/Test", parentMaterial: "/Valid", parameters: {} },
+    expected: "success"
+  },
+  {
+    scenario: "Border: Extreme color param [255,255,255,0]",
+    toolName: "manage_asset",
+    arguments: { action: "create_material_instance", name: "TestExtreme", path: "/Game/Test", parentMaterial: "/Valid", parameters: { BaseColor: [255, 255, 255, 0] } },
+    expected: "success"
+  },
+  {
+    scenario: "Error: Non-material duplicate",
+    toolName: "manage_asset",
+    arguments: { action: "duplicate", assetPath: "/Engine/BasicShapes/Cube" },
+    expected: "error|not_material"
+  },
+  // --- New Test Cases (+20) ---
+  {
+    scenario: "Create Unlit Material",
+    toolName: "manage_asset",
+    arguments: { action: "create_material", name: "M_Unlit_TC", path: "/Game/Materials", properties: { ShadingModel: "Unlit" } },
+    expected: "success"
+  },
+  {
+    scenario: "Create Translucent Material",
+    toolName: "manage_asset",
+    arguments: { action: "create_material", name: "M_Translucent_TC", path: "/Game/Materials", properties: { BlendMode: "Translucent" } },
+    expected: "success"
+  },
+  {
+    scenario: "Create Two-Sided Material",
+    toolName: "manage_asset",
+    arguments: { action: "create_material", name: "M_TwoSided_TC", path: "/Game/Materials", properties: { TwoSided: true } },
+    expected: "success"
+  },
+  {
+    scenario: "Add Scalar Parameter",
+    toolName: "manage_asset",
+    arguments: { action: "add_material_parameter", assetPath: "/Game/Materials/M_MasterMaterial_TC", parameterName: "Roughness", parameterType: "Scalar", defaultValue: 0.5 },
+    expected: "success"
+  },
+  {
+    scenario: "Add Vector Parameter",
+    toolName: "manage_asset",
+    arguments: { action: "add_material_parameter", assetPath: "/Game/Materials/M_MasterMaterial_TC", parameterName: "EmissiveColor", parameterType: "Vector", defaultValue: [1, 0, 0, 1] },
+    expected: "success"
+  },
+  {
+    scenario: "Add Texture Parameter",
+    toolName: "manage_asset",
+    arguments: { action: "add_material_parameter", assetPath: "/Game/Materials/M_MasterMaterial_TC", parameterName: "BaseTexture", parameterType: "Texture" },
+    expected: "success"
+  },
+  {
+    scenario: "Add Static Switch",
+    toolName: "manage_asset",
+    arguments: { action: "add_material_parameter", assetPath: "/Game/Materials/M_MasterMaterial_TC", parameterName: "UseTexture", parameterType: "StaticSwitch", defaultValue: false },
+    expected: "success"
+  },
+  {
+    scenario: "Create Constant Instance",
+    toolName: "manage_asset",
+    arguments: { action: "create_material_instance", name: "MIC_Test", path: "/Game/Materials", parentMaterial: "/Game/Materials/M_MasterMaterial_TC", constant: true },
+    expected: "success"
+  },
+  {
+    scenario: "List Material Instances",
+    toolName: "manage_asset",
+    arguments: { action: "list_instances", assetPath: "/Game/Materials/M_MasterMaterial_TC" },
+    expected: "success"
+  },
+  {
+    scenario: "Reset Instance Parameters",
+    toolName: "manage_asset",
+    arguments: { action: "reset_instance_parameters", assetPath: "/Game/Materials/MI_TestInstance_TC" },
+    expected: "success"
+  },
+  {
+    scenario: "Check Material Exists",
+    toolName: "manage_asset",
+    arguments: { action: "exists", assetPath: "/Game/Materials/M_MasterMaterial_TC" },
+    expected: "true"
+  },
+  {
+    scenario: "Get Material Stats",
+    toolName: "manage_asset",
+    arguments: { action: "get_material_stats", assetPath: "/Game/Materials/M_MasterMaterial_TC" },
+    expected: "success"
+  },
+  {
+    scenario: "Error: Add existing parameter",
+    toolName: "manage_asset",
+    arguments: { action: "add_material_parameter", assetPath: "/Game/Materials/M_MasterMaterial_TC", parameterName: "Roughness", parameterType: "Scalar" },
+    expected: "success"
+  },
+  {
+    scenario: "Error: Create invalid shading model",
+    toolName: "manage_asset",
+    arguments: { action: "create_material", name: "M_Invalid", path: "/Game/Materials", properties: { ShadingModel: "InvalidModel" } },
+    expected: "error|invalid_property"
+  },
+  {
+    scenario: "Edge: Translucent Unlit",
+    toolName: "manage_asset",
+    arguments: { action: "create_material", name: "M_Glass", path: "/Game/Materials", properties: { ShadingModel: "Unlit", BlendMode: "Translucent" } },
+    expected: "success"
+  },
+  {
+    scenario: "Validation: Missing parent for instance",
+    toolName: "manage_asset",
+    arguments: { action: "create_material_instance", name: "MI_Orphan", path: "/Game/Materials" },
+    expected: "error|missing_parent"
+  },
+  {
+    scenario: "Cleanup New Materials",
+    toolName: "manage_asset",
+    arguments: {
+      action: "delete", assetPaths: [
+        "/Game/Materials/M_Unlit_TC",
+        "/Game/Materials/M_Translucent_TC",
+        "/Game/Materials/M_TwoSided_TC",
+        "/Game/Materials/MIC_Test",
+        "/Game/Materials/M_Glass",
+        "/Game/Materials/TC/M_BaseMaterial_TC",
+        "/Game/Materials/MI_TestInstance_TC",
+        "/Game/Materials/M_MasterMaterial_TC"
+      ]
+    },
+    expected: "success"
+  }
+];
+
+await runToolTests('Materials', testCases);

package/tests/test-niagara.mjs

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/**
+ * Condensed Effects & Visual Test Suite (15 cases)
+ * Tool: manage_effect
+ */
+
+import { runToolTests } from './test-runner.mjs';
+
+const systemPath = '/Game/Effects/Niagara/TC_System';
+
+const testCases = [
+  // 1. Create real Niagara System asset first
+  { scenario: 'Create real Niagara System', toolName: 'manage_effect', arguments: { action: 'create_niagara_system', name: 'TC_System', template: 'Fountain' }, expected: 'success - system created' },
+
+  { scenario: 'Spawn basic particle (engine)', toolName: 'manage_effect', arguments: { action: 'particle', preset: '/Engine/BasicShapes/Cube', location: { x: 0, y: 0, z: 100 } }, expected: 'success - particle spawned' },
+  { scenario: 'Spawn smoke particle', toolName: 'manage_effect', arguments: { action: 'particle', preset: '/Engine/BasicShapes/Cube', location: { x: 200, y: 0, z: 100 } }, expected: 'success - smoke spawned' },
+  { scenario: 'Spawn explosion particle', toolName: 'manage_effect', arguments: { action: 'particle', preset: '/Engine/BasicShapes/Cube', location: { x: 400, y: 0, z: 100 } }, expected: 'success - explosion spawned' },
+  { scenario: 'Create debug line', toolName: 'manage_effect', arguments: { action: 'debug_shape', shapeType: 'Line', start: { x: 0, y: 0, z: 0 }, end: { x: 1000, y: 0, z: 0 }, color: { r: 1, g: 0, b: 0, a: 1 } }, expected: 'success - debug drawn' },
+  { scenario: 'Create debug box', toolName: 'manage_effect', arguments: { action: 'debug_shape', shapeType: 'Box', location: { x: 0, y: 0, z: 100 }, extent: { x: 100, y: 100, z: 100 } }, expected: 'success - debug box' },
+  { scenario: 'Create debug sphere', toolName: 'manage_effect', arguments: { action: 'debug_shape', shapeType: 'Sphere', location: { x: 500, y: 500, z: 100 }, radius: 150 }, expected: 'success - debug sphere' },
+
+  // Use the created system path
+  { scenario: 'Spawn a simple Niagara system (safe path)', toolName: 'manage_effect', arguments: { action: 'niagara', systemPath: systemPath, location: { x: 0, y: 0, z: 200 }, autoActivate: true, name: 'TC_System_Actor' }, expected: 'success - niagara spawned', timeout: 180000 },
+  { scenario: 'Spawn niagara with parameters (best-effort)', toolName: 'manage_effect', arguments: { action: 'niagara', systemPath: systemPath, parameters: { FloatParam: 1.0 }, location: { x: 100, y: 100, z: 200 } }, expected: 'success - niagara params applied' },
+  { scenario: 'Create volumetric fog (lightweight)', toolName: 'manage_effect', arguments: { action: 'create_volumetric_fog', fogName: 'TC_Fog', bounds: { min: { x: -500, y: -500, z: 0 }, max: { x: 500, y: 500, z: 500 } }, density: 0.01, systemPath: systemPath }, expected: 'success - fog created' },
+  { scenario: 'Create dynamic light pulse', toolName: 'manage_effect', arguments: { action: 'create_dynamic_light', lightName: 'TC_Pulse', lightType: 'Point', location: { x: 0, y: 0, z: 300 }, intensity: 2000, pulse: { enabled: true, frequency: 1.0 } }, expected: 'success - dynamic light created' },
+  { scenario: 'Create particle trail simple', toolName: 'manage_effect', arguments: { action: 'create_particle_trail', trailName: 'TC_Trail', emitterCount: 2, particleCount: 50, lifetime: 2.0, systemPath: systemPath }, expected: 'success - particle trail created' },
+  { scenario: 'Create environmental effect', toolName: 'manage_effect', arguments: { action: 'create_environment_effect', effectType: 'Leaves', count: 20, spawnArea: { min: { x: -500, y: -500, z: 0 }, max: { x: 500, y: 500, z: 200 } }, systemPath: systemPath }, expected: 'success - environment effect' },
+  { scenario: 'Create impact effect (best-effort)', toolName: 'manage_effect', arguments: { action: 'create_impact_effect', surfaceType: 'Default', location: { x: 100, y: 100, z: 100 }, effects: {}, systemPath: systemPath }, expected: 'success - impact effect' },
+  { scenario: 'Create niagara ribbon (best-effort)', toolName: 'manage_effect', arguments: { action: 'create_niagara_ribbon', ribbonName: 'TC_Ribbon', startPoint: { x: -200, y: 0, z: 200 }, endPoint: { x: 200, y: 0, z: 200 }, width: 10, segments: 10, systemPath: systemPath }, expected: 'success - ribbon created' },
+
+  { scenario: 'Cleanup effect actors', toolName: 'manage_effect', arguments: { action: 'cleanup', filter: 'TC_' }, expected: 'success - cleanup performed' },
+  { scenario: 'Niagara - Create System (redundant check)', toolName: 'manage_effect', arguments: { action: 'niagara', systemPath: systemPath, location: { x: 1000, y: 0, z: 100 }, autoActivate: false }, expected: 'success' },
+  { scenario: 'Niagara - Override Parameter', toolName: 'manage_effect', arguments: { action: 'set_niagara_parameter', systemName: 'TC_System', parameterName: 'User.FloatParam', parameterType: 'Float', value: 2.5, isUserParameter: true }, expected: 'error' },
+  { scenario: 'Niagara - Activate', toolName: 'manage_effect', arguments: { action: 'activate_effect', actorName: 'TC_System' }, expected: 'error' },
+  {
+    scenario: "Error: Invalid Niagara system",
+    toolName: "manage_effect",
+    arguments: { action: "niagara", systemPath: "/Invalid/System" },
+    expected: "SYSTEM_NOT_FOUND"
+  },
+  {
+    scenario: "Edge: Scale 0",
+    toolName: "manage_effect",
+    arguments: { action: "niagara", systemPath: systemPath, scale: 0 },
+    expected: "success"
+  },
+  {
+    scenario: "Border: Invalid param type",
+    toolName: "manage_effect",
+    arguments: { action: "set_niagara_parameter", systemName: "Test", parameterName: "FloatParam", parameterType: "Invalid", value: 1 },
+    expected: "error"
+  },
+  {
+    scenario: "Edge: Empty filter cleanup",
+    toolName: "manage_effect",
+    arguments: { action: "cleanup", filter: "" },
+    expected: "success|no_op"
+  },
+  // --- New Test Cases (+20) ---
+  {
+    scenario: "Create Empty System",
+    toolName: "manage_effect",
+    arguments: { action: "create_niagara_system", name: "NS_Empty_TC", path: "/Game/Effects/Niagara" },
+    expected: "success"
+  },
+  {
+    scenario: "Create System from Emitters",
+    toolName: "manage_effect",
+    arguments: { action: "create_niagara_system", name: "NS_FromEmitters_TC", path: "/Game/Effects/Niagara", emitterAssets: ["/Engine/Niagara/Emitters/Fountain"] },
+    expected: "success"
+  },
+  // SKIPPED: Add/Remove Emitter not implemented in C++ yet
+  // {
+  //   scenario: "Add Emitter to System",
+  //   toolName: "manage_effect",
+  //   arguments: { action: "add_emitter", systemPath: "/Game/Effects/Niagara/NS_Empty_TC", emitterPath: "/Engine/Niagara/Emitters/OmniDirectionalBurst" },
+  //   expected: "success"
+  // },
+  // {
+  //   scenario: "Remove Emitter from System",
+  //   toolName: "manage_effect",
+  //   arguments: { action: "remove_emitter", systemPath: "/Game/Effects/Niagara/NS_Empty_TC", emitterName: "OmniDirectionalBurst" },
+  //   expected: "success"
+  // },
+  {
+    scenario: "Re-spawn TC_System_Actor for parameter tests",
+    toolName: "manage_effect",
+    arguments: { action: "niagara", systemPath: systemPath, location: { x: 0, y: 0, z: 200 }, autoActivate: true, name: "TC_System_Actor" },
+    expected: "success"
+  },
+  {
+    scenario: "Set Float Parameter",
+    toolName: "manage_effect",
+    arguments: { action: "set_niagara_parameter", actorName: "TC_System_Actor", parameterName: "User.SpawnRate", value: 50.0, type: "float" },
+    expected: "success"
+  },
+  {
+    scenario: "Set Color Parameter",
+    toolName: "manage_effect",
+    arguments: { action: "set_niagara_parameter", actorName: "TC_System_Actor", parameterName: "User.Color", value: [1.0, 0.0, 0.0, 1.0], type: "color" },
+    expected: "success"
+  },
+  /*
+  {
+    scenario: "Set Vector Parameter",
+    toolName: "manage_effect",
+    arguments: { action: "set_niagara_parameter", actorName: "TC_System_Actor", parameterName: "User.Position", value: [100.0, 0.0, 0.0], type: "vector" },
+    expected: "success"
+  },
+  */
+  {
+    scenario: "Set Bool Parameter",
+    toolName: "manage_effect",
+    arguments: { action: "set_niagara_parameter", actorName: "TC_System_Actor", parameterName: "User.Enabled", value: true, type: "bool" },
+    expected: "success"
+  },
+  {
+    scenario: "Activate System Actor",
+    toolName: "manage_effect",
+    arguments: { action: "activate", actorName: "TC_System_Actor" },
+    expected: "success"
+  },
+  {
+    scenario: "Deactivate System Actor",
+    toolName: "manage_effect",
+    arguments: { action: "deactivate", actorName: "TC_System_Actor" },
+    expected: "success"
+  },
+  {
+    scenario: "Reset System Simulation",
+    toolName: "manage_effect",
+    arguments: { action: "reset", actorName: "TC_System_Actor" },
+    expected: "success"
+  },
+  {
+    scenario: "Advance Simulation",
+    toolName: "manage_effect",
+    arguments: { action: "advance_simulation", actorName: "TC_System_Actor", deltaTime: 0.1, steps: 1 },
+    expected: "success"
+  },
+  {
+    scenario: "Spawn at absolute location",
+    toolName: "manage_effect",
+    arguments: { action: "niagara", systemPath: systemPath, location: { x: 500, y: 500, z: 500 }, rotation: { pitch: 0, yaw: 90, roll: 0 }, scale: { x: 2, y: 2, z: 2 } },
+    expected: "success"
+  },
+  {
+    scenario: "Spawn attached to actor",
+    toolName: "manage_effect",
+    arguments: { action: "niagara", systemPath: systemPath, attachToActor: "TC_Cube", attachPoint: "RootComponent" },
+    expected: "success"
+  },
+  {
+    scenario: "Error: Add invalid emitter",
+    toolName: "manage_effect",
+    arguments: { action: "add_emitter", systemPath: systemPath, emitterPath: "/Game/InvalidEmitter" },
+    expected: "error|not_found"
+  },
+  {
+    scenario: "Error: Set invalid parameter type",
+    toolName: "manage_effect",
+    arguments: { action: "set_niagara_parameter", systemPath: systemPath, parameterName: "User.SpawnRate", value: "invalid", type: "float" },
+    expected: "error"
+  },
+  {
+    scenario: "Edge: Advance simulation 0 time",
+    toolName: "manage_effect",
+    arguments: { action: "advance_simulation", actorName: "TC_System_Actor", deltaTime: 0 },
+    expected: "success|no_op"
+  },
+  {
+    scenario: "Cleanup Niagara Tests",
+    toolName: "manage_asset",
+    arguments: {
+      action: "delete", assetPaths: [
+        "/Game/Effects/Niagara/NS_Empty_TC",
+        "/Game/Effects/Niagara/NS_FromEmitters_TC"
+      ]
+    },
+    expected: "success"
+  }
+];
+
+await runToolTests('Effects & Visual', testCases);

package/tests/test-no-inline-python.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+import fs from 'node:fs/promises';
+import path from 'node:path';
+import { fileURLToPath } from 'node:url';
+
+const __dirname = path.dirname(fileURLToPath(import.meta.url));
+const repoRoot = path.resolve(__dirname, '..');
+const srcRoot = path.resolve(repoRoot, 'src');
+
+function isPositionInsideLiteralOrComment(content, pos) {
+  let inSingle = false;
+  let inDouble = false;
+  let inBacktick = false;
+  let inLineComment = false;
+  let inBlockComment = false;
+
+  for (let i = 0; i < pos; i += 1) {
+    const ch = content[i];
+    const next = content[i + 1];
+
+    if (inLineComment) {
+      if (ch === '\n') inLineComment = false;
+      continue;
+    }
+    if (inBlockComment) {
+      if (ch === '*' && next === '/') {
+        inBlockComment = false; i += 1; continue;
+      }
+      continue;
+    }
+    if (inSingle) {
+      if (ch === "\\") { i += 1; continue; }
+      if (ch === "'") { inSingle = false; }
+      continue;
+    }
+    if (inDouble) {
+      if (ch === "\\") { i += 1; continue; }
+      if (ch === '"') { inDouble = false; }
+      continue;
+    }
+    if (inBacktick) {
+      if (ch === "\\") { i += 1; continue; }
+      if (ch === '`') { inBacktick = false; }
+      continue;
+    }
+
+    // Not inside any literal/comment
+    if (ch === '/' && next === '/') { inLineComment = true; i += 1; continue; }
+    if (ch === '/' && next === '*') { inBlockComment = true; i += 1; continue; }
+    if (ch === "'") { inSingle = true; continue; }
+    if (ch === '"') { inDouble = true; continue; }
+    if (ch === '`') { inBacktick = true; continue; }
+  }
+
+  return inSingle || inDouble || inBacktick || inLineComment || inBlockComment;
+}
+
+async function listTsFiles(dir) {
+  const out = [];
+  const entries = await fs.readdir(dir, { withFileTypes: true });
+  for (const ent of entries) {
+    if (ent.name === 'node_modules' || ent.name === 'dist' || ent.name === '.git') continue;
+    const full = path.join(dir, ent.name);
+    if (ent.isDirectory()) {
+      out.push(...(await listTsFiles(full)));
+    } else if (ent.isFile() && full.endsWith('.ts')) {
+      out.push(full);
+    }
+  }
+  return out;
+}
+
+function toLineCol(content, index) {
+  const before = content.slice(0, index);
+  const lines = before.split(/\r?\n/);
+  const line = lines.length;
+  const col = lines[lines.length - 1].length + 1;
+  return { line, col };
+}
+
+async function main() {
+  const patterns = [
+    { name: 'import_unreal', re: /import\s+unreal\b/g },
+    { name: 'python_def', re: /\bdef\s+[A-Za-z_][A-Za-z0-9_]*/g },
+    { name: 'print_result', re: /print\s*\(\s*['\"]RESULT:/g },
+    { name: 'json_dumps', re: /json\.dumps\s*\(/g }
+  ];
+
+  const files = await listTsFiles(srcRoot);
+  const failures = [];
+
+  for (const f of files) {
+    const content = await fs.readFile(f, 'utf8');
+    for (const p of patterns) {
+      let m;
+      while ((m = p.re.exec(content)) !== null) {
+        const idx = m.index;
+        if (isPositionInsideLiteralOrComment(content, idx)) continue;
+        const pos = toLineCol(content, idx);
+        const snippetLine = content.split(/\r?\n/)[pos.line - 1] ?? '';
+        failures.push({ file: f, pattern: p.name, match: m[0], line: pos.line, col: pos.col, snippet: snippetLine.trim() });
+      }
+    }
+  }
+
+  if (failures.length > 0) {
+    console.error('\nInline Python detected outside of string literals or comments in TypeScript source files:');
+    for (const fail of failures) {
+      console.error(`\n - ${path.relative(repoRoot, fail.file)}:${fail.line}:${fail.col}  [${fail.pattern}]  -> ${fail.snippet}`);
+    }
+    console.error('\nPlease move Python code into a dedicated helper module and keep TypeScript files free of raw Python.');
+    process.exitCode = 1;
+    return;
+  }
+
+  console.log('No inline Python found in TypeScript source files (outside of string literals/comments).');
+}
+
+main().catch((err) => {
+  console.error('Test failed with unexpected error:', err);
+  process.exitCode = 2;
+});