code updated in app and synth

app.py

@@ -1,6 +1,7 @@
 import os
 import gradio as gr
 from translator.agent import TranslationAgent
+import re
 
 agent = TranslationAgent()
 
@@ -9,26 +10,31 @@ description = "Paste a Unity C# script and get Unreal C++ (.h/.cpp) + Unreal Blu
 
 
 def extract_class_name(csharp_code: str) -> str:
-    import re
+    """Extracts Unity class name for file naming."""
     match = re.search(r"class\s+(\w+)", csharp_code)
     return match.group(1) if match else "MyActor"
 
 
 def split_cpp_code(full_cpp_code: str):
-    """Split combined C++ output into .h and .cpp sections."""
+    """
+    Split model output into .h and .cpp parts using file markers like:
+    ---FILE: MyActor.h---
+    ---FILE: MyActor.cpp---
+    """
     if not full_cpp_code:
         return "", ""
-    lines = full_cpp_code.splitlines()
-    header_lines, cpp_lines = [], []
-    in_header = True
-    for line in lines:
-        if line.strip().startswith("#include") or line.strip().endswith(".cpp"):
-            in_header = False
-        if in_header:
-            header_lines.append(line)
-        else:
-            cpp_lines.append(line)
-    return "\n".join(header_lines).strip(), "\n".join(cpp_lines).strip()
+
+    header_match = re.search(r"---FILE:\s*.*?\.h---([\s\S]*?)(?=---FILE:|$)", full_cpp_code)
+    cpp_match = re.search(r"---FILE:\s*.*?\.cpp---([\s\S]*?)(?=---FILE:|$)", full_cpp_code)
+
+    header_code = header_match.group(1).strip() if header_match else ""
+    cpp_code = cpp_match.group(1).strip() if cpp_match else full_cpp_code.strip()
+
+    # Cleanup any ``` fences if the model wrapped code blocks
+    header_code = re.sub(r"^```[a-zA-Z]*|```$", "", header_code, flags=re.MULTILINE).strip()
+    cpp_code = re.sub(r"^```[a-zA-Z]*|```$", "", cpp_code, flags=re.MULTILINE).strip()
+
+    return header_code, cpp_code
 
 
 def do_translate(csharp_code, target_format, model_choice):
@@ -41,15 +47,17 @@ def do_translate(csharp_code, target_format, model_choice):
     # Split .h / .cpp parts if present
     header_code, cpp_code_only = split_cpp_code(cpp_code)
 
-    # Save files
+    # Save to temporary files for download
     h_filename = f"{class_name}.h"
     cpp_filename = f"{class_name}.cpp"
+
     with open(h_filename, "w", encoding="utf-8") as h:
         h.write(header_code or "// No header generated")
+
     with open(cpp_filename, "w", encoding="utf-8") as c:
         c.write(cpp_code_only or "// No cpp generated")
 
-    # Split blueprint output into main and logs if available
+    # Split blueprint output into main and extra sections if available
     blueprint_parts = blueprint_code.split("###")
     main_script = blueprint_parts[0].strip()
     extra_info = blueprint_parts[1].strip() if len(blueprint_parts) > 1 else ""
@@ -57,6 +65,7 @@ def do_translate(csharp_code, target_format, model_choice):
     return header_code, cpp_code_only, main_script, extra_info, h_filename, cpp_filename
 
 
+# Gradio UI
 with gr.Blocks(title=title) as demo:
     gr.Markdown(f"### 🧠 {title}")
     gr.Markdown(description)
@@ -69,12 +78,20 @@ with gr.Blocks(title=title) as demo:
         )
 
     with gr.Row():
-        target_format = gr.Radio(["cpp", "blueprint", "both"], value="both", label="Target Format")
-        model_choice = gr.Radio(["hf", "openai"], value="hf", label="Model Backend")
+        target_format = gr.Radio(
+            ["cpp", "blueprint", "both"],
+            value="both",
+            label="Target Format"
+        )
+        model_choice = gr.Radio(
+            ["hf", "openai"],
+            value="hf",
+            label="Model Backend"
+        )
 
     translate_btn = gr.Button("🔁 Translate")
 
-    # Tabs for output organization
+    # C++ output tab
     with gr.Tab("C++ Output"):
         with gr.Row():
             header_box = gr.Code(label=".h (Header File)", language="cpp")
@@ -83,12 +100,16 @@ with gr.Blocks(title=title) as demo:
             download_h = gr.File(label="Download .h")
             download_cpp = gr.File(label="Download .cpp")
 
+    # Blueprint output tab
     with gr.Tab("Blueprint Output"):
         with gr.Row():
             blueprint_main = gr.Textbox(label="Blueprint Python Script", lines=15)
         with gr.Row():
-            blueprint_notes = gr.Textbox(label="Blueprint Hints / Logs", lines=10,
-                                         placeholder="Any additional output, logs, or notes will appear here.")
+            blueprint_notes = gr.Textbox(
+                label="Blueprint Hints / Logs",
+                lines=10,
+                placeholder="Any additional output, logs, or notes will appear here."
+            )
 
     translate_btn.click(
         do_translate,

translator/synth.py

@@ -3,47 +3,72 @@ from .llm_client import generate_with_hf, generate_with_openai
 def synthesize_cpp(parsed: dict, mapping: dict, prompt_context: str = "", model_backend="hf") -> str:
     """
     Converts Unity C# parsed structure into Unreal Engine C++ (header + source).
+    Always returns code with clear file markers:
+    ---FILE: ClassName.h---
+    ---FILE: ClassName.cpp---
     """
+    class_name = parsed.get("classes", [{}])[0].get("name", "MyActor")
+
     prompt = f"""
-    Translate the following Unity C# class to idiomatic Unreal Engine C++ (header and source).
-    Mapping rules: {mapping}
-    Parsed structure: {parsed}
+    You are an expert Unreal Engine C++ developer.
+    Translate the following Unity C# class into idiomatic Unreal C++.
+
+    ✅ Follow these rules:
+    - Create TWO files with exact markers:
+      ---FILE: {class_name}.h---
+      (Header file)
+      ---FILE: {class_name}.cpp---
+      (Implementation file)
+    - Use Unreal macros like UCLASS(), UPROPERTY(), and UFUNCTION() appropriately.
+    - Include necessary Unreal headers.
+    - Ensure code compiles cleanly.
+    - Use PascalCase for class and method names.
+    - Avoid Unity-specific APIs; map them via given rules.
 
-    Generate two files separated with markers:
-    ---FILE: MyActor.h---
-    [contents]
-    ---FILE: MyActor.cpp---
-    [contents]
+    Mapping rules:
+    {mapping}
+
+    Parsed structure:
+    {parsed}
 
-    Be concise, compile-ready, and use UPROPERTY/UFUNCTION macros where suitable.
     {prompt_context}
     """
 
     if model_backend == "openai":
-        from .llm_client import generate_with_openai
         return generate_with_openai(prompt, model="gpt-4o-mini")
     else:
-        from .llm_client import generate_with_hf
         return generate_with_hf(prompt, model="mistralai/Mistral-7B-Instruct-v0.3")
 
 
 def synthesize_blueprint_python(parsed: dict, mapping: dict, model_backend="hf") -> str:
+    """
+    Generates Unreal Python Editor script that creates a Blueprint equivalent
+    of the Unity class (BP_<ClassName>).
+    """
+    class_name = parsed.get("classes", [{}])[0].get("name", "MyActor")
+
     prompt = f"""
-    Given this parsed Unity class and mapping rules, produce a Python Editor script using Unreal's Python API
-    that will create a Blueprint Actor in /Game/Blueprints named BP_<ClassName> with:
-      - A StaticMeshComponent as root
-      - A float property 'RotationSpeed' exposed to Blueprints
-      - A Tick override that rotates actor by RotationSpeed * DeltaTime
+    You are an Unreal Engine Python scripting expert.
+    Convert the given Unity C# class into an Unreal Python Editor script
+    that generates a Blueprint Actor named BP_{class_name}.
 
-    Provide only the Python file content.
+    Requirements:
+    - Use Unreal Python API (unreal module).
+    - Create Blueprint under /Game/Blueprints/BP_{class_name}.
+    - Add StaticMeshComponent as root.
+    - Add float property 'RotationSpeed' exposed to Blueprint.
+    - Implement a Tick method to rotate actor: RotationSpeed * DeltaTime.
+    - Include import statements and comments for clarity.
+    - Output only the full Python script (no explanations).
 
-    Parsed: {parsed}
-    Mapping: {mapping}
+    Parsed structure:
+    {parsed}
+
+    Mapping rules:
+    {mapping}
     """
 
     if model_backend == "openai":
-        from .llm_client import generate_with_openai
         return generate_with_openai(prompt, model="gpt-4o-mini")
     else:
-        from .llm_client import generate_with_hf
-        return generate_with_hf(prompt, model="mistralai/Mistral-7B-Instruct-v0.3")
+        return generate_with_hf(prompt, model="mistralai/Mistral-7B-Instruct-v0.3")