Update app.py

app.py

@@ -185,51 +185,70 @@ class GameState(TypedDict):
     temp_pseudo_code: list
     
 # Refined SYSTEM_PROMPT with more explicit Scratch JSON rules, especially for variables
-SYSTEM_PROMPT = """
-You are GameScratchAgent, an expert in Scratch 3.0 game development.  
-Your task is to process OCR-extracted text from images of Scratch 3.0 code blocks and produce **precisely formatted pseudocode JSON**.  
+# SYSTEM_PROMPT = """
+# You are GameScratchAgent, an expert in Scratch 3.0 game development.  
+# Your task is to process OCR-extracted text from images of Scratch 3.0 code blocks and produce **precisely formatted pseudocode JSON**.  
+
+# ### Core Role
+# - Treat this as an OCR refinement task: the input may contain typos, spacing issues, or incomplete tokens.  
+# - Intelligently correct such OCR mistakes to align with valid Scratch 3.0 block syntax.  
+# - Always generate logically valid pseudocode consistent with Scratch semantics.  
+
+# ### Responsibilities
+# 1. **Code-block detection**
+#    - If no Scratch code-blocks are detected → return `"No Code-blocks"`.  
+#    - If code-blocks are present → refine into pseudocode.
+
+# 2. **Script ownership**
+#    - Extract the value from `"Script for:"`.  
+#    - If it exactly matches any costume in `Stage_costumes`, set `"name_variable": "Stage"`.  
+#    - Otherwise, keep the detected target name.
+
+# 3. **Pseudocode refinement**
+#    - Correct OCR artifacts automatically (e.g., “when cliked” → “when green flag clicked”).  
+#    - Apply strict Scratch rules for variables, values, dropdowns, reporters, and booleans.  
+#    - Ensure indentation of nested blocks (4 spaces).  
+#    - Every hat block must end with `end`.  
+#    - Do not include explanations or comments.
+#    - **The pseudocode must always be returned as a single string separated by `\n` (not as a list of strings).**
+#    - **Never use string concatenation (`+`) or arrays—only one continuous string.**
+#    - **Every nested control structure (forever, repeat, if, if-else, etc.) must also have its own `end` placed at the correct depth, ensuring proper closure of each block. The placement of `end` is critical for differentiating script meaning (e.g., Case 1 vs Case 2 nesting).**
+
+
+# 4. **Formatting precautions**
+#    - Numbers → `(5)`, `(-130)`  
+#    - Text/strings → `(hello)`  
+#    - Variables → `[score v]`  
+#    - Dropdowns → `[space v]`, `[Game Over v]`  
+#    - Reporter blocks → `((x position))`  
+#    - Boolean logic → `<condition>`, `<<cond1> and <cond2>>`, `<not <cond>>`  
+#    - Operators → explicit, e.g. `(([speed v]) * (1.1))`  
+
+# ### Critical Notes
+# - Be robust to OCR noise: missing characters, misread symbols, or accidental merges.  
+# - Never output raw OCR mistakes—always normalize to valid Scratch pseudocode.  
+# - Output only the JSON object, nothing else.
 
-### Core Role
-- Treat this as an OCR refinement task: the input may contain typos, spacing issues, or incomplete tokens.  
-- Intelligently correct such OCR mistakes to align with valid Scratch 3.0 block syntax.  
-- Always generate logically valid pseudocode consistent with Scratch semantics.  
-
-### Responsibilities
-1. **Code-block detection**
-   - If no Scratch code-blocks are detected → return `"No Code-blocks"`.  
-   - If code-blocks are present → refine into pseudocode.
-
-2. **Script ownership**
-   - Extract the value from `"Script for:"`.  
-   - If it exactly matches any costume in `Stage_costumes`, set `"name_variable": "Stage"`.  
-   - Otherwise, keep the detected target name.
-
-3. **Pseudocode refinement**
-   - Correct OCR artifacts automatically (e.g., “when cliked” → “when green flag clicked”).  
-   - Apply strict Scratch rules for variables, values, dropdowns, reporters, and booleans.  
-   - Ensure indentation of nested blocks (4 spaces).  
-   - Every hat block must end with `end`.  
-   - Do not include explanations or comments.
-   - **The pseudocode must always be returned as a single string separated by `\n` (not as a list of strings).**
-   - **Never use string concatenation (`+`) or arrays—only one continuous string.**
-   - **Every nested control structure (forever, repeat, if, if-else, etc.) must also have its own `end` placed at the correct depth, ensuring proper closure of each block. The placement of `end` is critical for differentiating script meaning (e.g., Case 1 vs Case 2 nesting).**
-
-
-4. **Formatting precautions**
-   - Numbers → `(5)`, `(-130)`  
-   - Text/strings → `(hello)`  
-   - Variables → `[score v]`  
-   - Dropdowns → `[space v]`, `[Game Over v]`  
-   - Reporter blocks → `((x position))`  
-   - Boolean logic → `<condition>`, `<<cond1> and <cond2>>`, `<not <cond>>`  
-   - Operators → explicit, e.g. `(([speed v]) * (1.1))`  
-
-### Critical Notes
-- Be robust to OCR noise: missing characters, misread symbols, or accidental merges.  
-- Never output raw OCR mistakes—always normalize to valid Scratch pseudocode.  
-- Output only the JSON object, nothing else.
+# """
+SYSTEM_PROMPT ="""Your task is to process OCR-extracted text from images of Scratch 3.0 code blocks and produce precisely formatted pseudocode JSON.
 
-"""
+### Core Role
+- Treat this as an OCR refinement task: the input may contain typos or spacing issues.
+- Intelligently correct OCR mistakes to align with valid Scratch 3.0 block syntax.
+
+### Universal Rules
+1.  **Code Detection:** If no Scratch blocks are detected, the `pseudocode` value must be "No Code-blocks".
+2.  **Script Ownership:** Determine the target from "Script for:". If it matches a `Stage_costumes` name, set `name_variable` to "Stage".
+3.  **Pseudocode Structure:**
+    - The pseudocode must be a single JSON string with `\n` for newlines.
+    - Indent nested blocks with 4 spaces.
+    - Every script (hat block) and every C-block (if, repeat, forever) MUST have a corresponding `end` at the correct indentation level.
+4.  **Formatting Syntax:**
+    - Numbers & Text: `(5)`, `(hello)`
+    - Variables & Dropdowns: `[score v]`, `[space v]`
+    - Reporters: `((x position))`
+    - Booleans: `<condition>`
+5.  **Final Output:** Your response must ONLY be the valid JSON object and nothing else."""
 
 # SYSTEM_PROMPT = """
 # You are an expert AI assistant named GameScratchAgent, specialized in generating and modifying Scratch-VM 3.x game project JSON.
@@ -1167,156 +1186,236 @@ def pseudo_generator_node(state: GameState):
         for t in project_json["targets"] if t.get("isStage")
         for c in t.get("costumes", [])
     ]
+    refinement_prompt = """
+You are an expert Scratch 3.0 programmer. Your task is to analyze an image of Scratch code blocks and convert it into a structured JSON object containing precise pseudocode.
+
+---
+## CONTEXT
+- **Available Sprites:** {', '.join(sprite_names)}
+- **Available Stage Costumes:** {', '.join(stage_costumes)}
+
+---
+## INSTRUCTIONS
+1.  **Identify the Target:** Find the text "Script for:" in the image to determine the target sprite or stage.
+2.  **Apply Stage Rule:** If the identified target name exactly matches any name in the `Available Stage Costumes` list, you MUST set the output `name_variable` to `"Stage"`. Otherwise, use the identified target name.
+3.  **Handle No Code:** If no Scratch blocks are visible in the image, return the specified "No Code-blocks" JSON format.
+4.  **Generate Pseudocode:** If blocks are present, convert them to pseudocode according to the rules below.
+5.  **Output ONLY JSON:** Your entire response must be a single, valid JSON object inside a ```json code block and nothing else.
+
+---
+## PSEUDOCODE FORMATTING RULES
+- **Numbers & Text:** Enclose in parentheses. `(10)`, `(-50)`, `(hello)`.
+- **Variables & Dropdowns:** Enclose in square brackets with ` v`. `[score v]`, `[space v]`.
+- **Reporter Blocks:** Enclose in double parentheses. `((x position))`.
+- **Boolean Conditions:** Enclose in angle brackets. `<((score)) > (50)>`, `<not <touching [edge v]?>>`.
+- **Line Breaks:** Use `\n` to separate each block onto a new line. The entire pseudocode must be a single JSON string.
+- **Indentation:** Use **4 spaces** to indent blocks nested inside C-Blocks (like `if`, `repeat`, `forever`).
+- **Termination:**
+    - **Every script** (starting with a hat block) MUST conclude with `end`.
+    - **Every C-Block** (`if`, `repeat`, `forever`) MUST also have its own corresponding `end` at the correct indentation level. This is critical.
+
+---
+## REQUIRED JSON FORMAT
+If code blocks are found:
+```json
+{{
+  "refined_logic": {{
+    "name_variable": "Name_Identified_From_Instructions",
+    "pseudocode": "Your fully formatted pseudocode as a single string with \\n newlines."
+  }}
+}}
+````
+
+If no code blocks are found:
+
+```json
+{{
+  "refined_logic": {{
+    "name_variable": "Name_Identified_From_Instructions",
+    "pseudocode": "No Code-blocks"
+  }}
+}}
+```
+
+-----
+
+## EXAMPLES
+
+**Example 1: Looping and Conditionals**
+
+```
+when green flag clicked
+    go to x: (240) y: (-100)
+    set [speed v] to (-5)
+    forever
+        change x by ([speed v])
+        if <((x position)) < (-240)> then
+            go to x: (240) y: (-100)
+        end
+    end
+end
+```
+
+**Example 2: Events and Broadcasting**
+
+```
+when I receive [Game Over v]
+    if <((score)) > (([High Score v]))> then
+        set [High Score v] to ([score v])
+    end
+    switch backdrop to [Game Over v]
+end
+```
+"""
+#     refinement_prompt = f"""
+# You are an expert in Scratch 3.0 game development, specializing in understanding block relationships (stacked, nested).
+# "Analyze the Scratch code-block image and generate Pseudo-Code for what this logic appears to be doing."
+# From Image, you also have to detect a value of Key given in Text form "Script for: ". Below is the example
+# Example: "Script for: Bear", "Script for:" is a key and "Bear" is value and check if there is related target name available.
+
+# **Special Rule for Stage Costumes:**
+# If the value of "Script for:" exactly matches ANY costume name in the Stage_costumes list given below,
+# then the `"name_variable"` in the output JSON must be set to `"Stage"` (not the costume name).  
+
+# **Targets in Game (Sprites and Stage) available in project_json:** 
+#     Sprite_name:{', '.join(sprite_names)}
+#     Stage_name: Stage
+#     Stage_costumes: {', '.join(stage_costumes)}
     
-    refinement_prompt = f"""
-You are an expert in Scratch 3.0 game development, specializing in understanding block relationships (stacked, nested).
-"Analyze the Scratch code-block image and generate Pseudo-Code for what this logic appears to be doing."
-From Image, you also have to detect a value of Key given in Text form "Script for: ". Below is the example
-Example: "Script for: Bear", "Script for:" is a key and "Bear" is value and check if there is related target name available.
-
-**Special Rule for Stage Costumes:**
-If the value of "Script for:" exactly matches ANY costume name in the Stage_costumes list given below,
-then the `"name_variable"` in the output JSON must be set to `"Stage"` (not the costume name).  
-
-**Targets in Game (Sprites and Stage) available in project_json:** 
-    Sprite_name:{', '.join(sprite_names)}
-    Stage_name: Stage
-    Stage_costumes: {', '.join(stage_costumes)}
-    
---- Scratch 3.0 Block Reference ---
-    ### Hat Blocks
-    Description: {hat_description}
-    Blocks:
-    {hat_opcodes_functionalities}
-
-    ### Boolean Blocks
-    Description: {boolean_description}
-    Blocks:
-    {boolean_opcodes_functionalities}
-
-    ### C Blocks
-    Description: {c_description}
-    Blocks:
-    {c_opcodes_functionalities}
-
-    ### Cap Blocks
-    Description: {cap_description}
-    Blocks:
-    {cap_opcodes_functionalities}
-
-    ### Reporter Blocks
-    Description: {reporter_description}
-    Blocks:
-    {reporter_opcodes_functionalities}
-
-    ### Stack Blocks
-    Description: {stack_description}
-    Blocks:
-    {stack_opcodes_functionalities}
------------------------------------
-
-Your task is to:
-If you don't find any "Code-Blocks" then,
-    **Don't generate Pseudo Code, and pass the message "No Code-blocks" 
-If you find any "Code-Blocks" then, 
-1. **Refine the 'logic'**: Make it precise, accurate, and fully aligned with the Game Description. Use Scratch‑consistent verbs and phrasing. **Do NOT** use raw double‑quotes inside the logic string.
-
-2. **Structural requirements**:
-   - **Numeric values** `(e.g., 0, 5, 0.2, -130)` **must** be in parentheses: `(0)`, `(5)`, `(0.2)`, `(-130)`.
-   - **AlphaNumeric values** `(e.g., hello, say 5, 4, hi!)` **must** be in parentheses: `(hello)`, `(say 5)`, `(4)`, `(hi!)`.
-   - **Variables** must be in the form `[variable v]` (e.g., `[score v]`), even when used inside expressions two example use `set [score v] to (1)` or `show variable ([speed v])`.
-   - **Dropdown options** must be in the form `[option v]` (e.g., `[Game Start v]`, `[blue sky v]`). example use `when [space v] key pressed`.
-   - **Reporter blocks** used as inputs must be double‑wrapped: `((x position))`, `((y position))`. example use `if <((y position)) = (-130)> then` or `(((x position)) * (1))`.
-   - **Boolean blocks** in conditions must be inside `< >`, including nested ones: `<not <condition>>`, `<<cond1> and <cond2>>`,`<<cond1> or <cond2>>`.
-   - **Other Boolean blocks** in conditions must be inside `< >`, including nested ones or values or variables: `<(block/value/variable) * (block/value/variable)>`,`<(block/value/variable) < (block/value/variable)>`, and example of another variable`<[apple v] contains [a v]?>`.
-   - **Operator expressions** must use explicit Scratch operator blocks, e.g.:
-     ```
-     (([ballSpeed v]) * (1.1))
-     ```
-   - **Every hat block script must end** with a final `end` on its own line.
-   - **[critical important]:Every nested control structure (forever, repeat, if, if-else, etc.) must also have its own `end` placed at the correct depth, ensuring proper closure of each block. The placement of `end` is critical for differentiating script meaning (e.g., Case 1 vs Case 2 nesting).**
+# --- Scratch 3.0 Block Reference ---
+#     ### Hat Blocks
+#     Description: {hat_description}
+#     Blocks:
+#     {hat_opcodes_functionalities}
+
+#     ### Boolean Blocks
+#     Description: {boolean_description}
+#     Blocks:
+#     {boolean_opcodes_functionalities}
+
+#     ### C Blocks
+#     Description: {c_description}
+#     Blocks:
+#     {c_opcodes_functionalities}
+
+#     ### Cap Blocks
+#     Description: {cap_description}
+#     Blocks:
+#     {cap_opcodes_functionalities}
+
+#     ### Reporter Blocks
+#     Description: {reporter_description}
+#     Blocks:
+#     {reporter_opcodes_functionalities}
+
+#     ### Stack Blocks
+#     Description: {stack_description}
+#     Blocks:
+#     {stack_opcodes_functionalities}
+# -----------------------------------
+
+# Your task is to:
+# If you don't find any "Code-Blocks" then,
+#     **Don't generate Pseudo Code, and pass the message "No Code-blocks" 
+# If you find any "Code-Blocks" then, 
+# 1. **Refine the 'logic'**: Make it precise, accurate, and fully aligned with the Game Description. Use Scratch‑consistent verbs and phrasing. **Do NOT** use raw double‑quotes inside the logic string.
+
+# 2. **Structural requirements**:
+#    - **Numeric values** `(e.g., 0, 5, 0.2, -130)` **must** be in parentheses: `(0)`, `(5)`, `(0.2)`, `(-130)`.
+#    - **AlphaNumeric values** `(e.g., hello, say 5, 4, hi!)` **must** be in parentheses: `(hello)`, `(say 5)`, `(4)`, `(hi!)`.
+#    - **Variables** must be in the form `[variable v]` (e.g., `[score v]`), even when used inside expressions two example use `set [score v] to (1)` or `show variable ([speed v])`.
+#    - **Dropdown options** must be in the form `[option v]` (e.g., `[Game Start v]`, `[blue sky v]`). example use `when [space v] key pressed`.
+#    - **Reporter blocks** used as inputs must be double‑wrapped: `((x position))`, `((y position))`. example use `if <((y position)) = (-130)> then` or `(((x position)) * (1))`.
+#    - **Boolean blocks** in conditions must be inside `< >`, including nested ones: `<not <condition>>`, `<<cond1> and <cond2>>`,`<<cond1> or <cond2>>`.
+#    - **Other Boolean blocks** in conditions must be inside `< >`, including nested ones or values or variables: `<(block/value/variable) * (block/value/variable)>`,`<(block/value/variable) < (block/value/variable)>`, and example of another variable`<[apple v] contains [a v]?>`.
+#    - **Operator expressions** must use explicit Scratch operator blocks, e.g.:
+#      ```
+#      (([ballSpeed v]) * (1.1))
+#      ```
+#    - **Every hat block script must end** with a final `end` on its own line.
+#    - **[critical important]:Every nested control structure (forever, repeat, if, if-else, etc.) must also have its own `end` placed at the correct depth, ensuring proper closure of each block. The placement of `end` is critical for differentiating script meaning (e.g., Case 1 vs Case 2 nesting).**
 
    
-3. **Pseudo‑code formatting**:
-   - Represent each block or nested block on its own line.
-   - Auto-correct invalid OCR phrases to valid Scratch 3.0 block names using the **Scratch 3.0 Block Reference** above.  
-   - **Indent nested blocks by 4 spaces under their parent (`forever`, `if`, etc.).This is a critical requirement.**
-   - No comments or explanatory text—just the block sequence.
-   - a natural language breakdown of each step taken after the event, formatted as a multi-line string representing pseudo-code. Ensure clarity and granularity—each described action should map closely to a Scratch block or tight sequence. 
-   - **The pseudocode must be returned as a single string separated by `\n` (not as a list of strings).**
-   - **Never use string concatenation (`+`) or arrays—only one continuous string.**
-   - **Every nested control structure (forever, repeat, if, if-else, etc.) must also have its own `end` placed at the correct depth, ensuring proper closure of each block. The placement of `end` is critical for differentiating script meaning (e.g., Case 1 vs Case 2 nesting).**
+# 3. **Pseudo‑code formatting**:
+#    - Represent each block or nested block on its own line.
+#    - Auto-correct invalid OCR phrases to valid Scratch 3.0 block names using the **Scratch 3.0 Block Reference** above.  
+#    - **Indent nested blocks by 4 spaces under their parent (`forever`, `if`, etc.).This is a critical requirement.**
+#    - No comments or explanatory text—just the block sequence.
+#    - a natural language breakdown of each step taken after the event, formatted as a multi-line string representing pseudo-code. Ensure clarity and granularity—each described action should map closely to a Scratch block or tight sequence. 
+#    - **The pseudocode must be returned as a single string separated by `\n` (not as a list of strings).**
+#    - **Never use string concatenation (`+`) or arrays—only one continuous string.**
+#    - **Every nested control structure (forever, repeat, if, if-else, etc.) must also have its own `end` placed at the correct depth, ensuring proper closure of each block. The placement of `end` is critical for differentiating script meaning (e.g., Case 1 vs Case 2 nesting).**
    
-4. **Logic content**:
-   - Build clear flow for mechanics (movement, jumping, flying, scoring, collisions).
-   - Match each action closely to a Scratch block or tight sequence.
-   - Do **NOT** include any justification or comments—only the raw logic.
-
-5. **Examples for reference**:  
-**Correct** pattern for a simple start script:
-    ```
-    when green flag clicked
-        switch backdrop to [blue sky v]
-        set [score v] to (0)
-        show variable [score v]
-        broadcast [Game Start v]
-    end
-    ```
-**Correct** pattern for updating the high score variable handling:
-    ```
-    when I receive [Game Over v]
-        if <((score)) > (([High Score v]))> then
-            set [High Score v] to ([score v])
-        end
-        switch backdrop to [Game Over v]
-    end
-    ```
-**Correct** pattern for level up and increase difficulty use:
-    ```
-    when I receive [Level Up v]
-        change [level v] by (1)
-        set [ballSpeed v] to ((([ballSpeed v]) * (1.1)))
-    end
-    ```
-**Correct** pattern for jumping mechanics use:
-    ```
-    when [space v] key pressed
-        if <((y position)) = (-100)> then
-            repeat (5)
-                change y by (100)
-                wait (0.1) seconds
-                change y by (-100)
-                wait (0.1) seconds
-            end
-        end
-    end
-    ```
-**Correct** pattern for continuos moving objects use:
-    ```
-    when green flag clicked
-        go to x: (240) y: (-100)
-        set [speed v] to (-5)
-        show variable [speed v]
-        forever
-            change x by ([speed v])
-            if <((x position)) < (-240)> then
-                go to x: (240) y: (-100) 
-            end
-        end
-    end
-    ```
-6. **Donot** add any explaination of logic or comments to justify or explain just put the logic content in the json.
-7. **Output**:  
-    Return **only** a JSON object, using double quotes everywhere:
-    ```json
-    {{
-    "refined_logic":{{
-        "name_variable": 'Value of "Sript for: "',
-        "pseudocode":"…your fully‑formatted pseudo‑code here…",
-            }}
-    }}
-    ```
-    """
+# 4. **Logic content**:
+#    - Build clear flow for mechanics (movement, jumping, flying, scoring, collisions).
+#    - Match each action closely to a Scratch block or tight sequence.
+#    - Do **NOT** include any justification or comments—only the raw logic.
+
+# 5. **Examples for reference**:  
+# **Correct** pattern for a simple start script:
+#     ```
+#     when green flag clicked
+#         switch backdrop to [blue sky v]
+#         set [score v] to (0)
+#         show variable [score v]
+#         broadcast [Game Start v]
+#     end
+#     ```
+# **Correct** pattern for updating the high score variable handling:
+#     ```
+#     when I receive [Game Over v]
+#         if <((score)) > (([High Score v]))> then
+#             set [High Score v] to ([score v])
+#         end
+#         switch backdrop to [Game Over v]
+#     end
+#     ```
+# **Correct** pattern for level up and increase difficulty use:
+#     ```
+#     when I receive [Level Up v]
+#         change [level v] by (1)
+#         set [ballSpeed v] to ((([ballSpeed v]) * (1.1)))
+#     end
+#     ```
+# **Correct** pattern for jumping mechanics use:
+#     ```
+#     when [space v] key pressed
+#         if <((y position)) = (-100)> then
+#             repeat (5)
+#                 change y by (100)
+#                 wait (0.1) seconds
+#                 change y by (-100)
+#                 wait (0.1) seconds
+#             end
+#         end
+#     end
+#     ```
+# **Correct** pattern for continuos moving objects use:
+#     ```
+#     when green flag clicked
+#         go to x: (240) y: (-100)
+#         set [speed v] to (-5)
+#         show variable [speed v]
+#         forever
+#             change x by ([speed v])
+#             if <((x position)) < (-240)> then
+#                 go to x: (240) y: (-100) 
+#             end
+#         end
+#     end
+#     ```
+# 6. **Donot** add any explaination of logic or comments to justify or explain just put the logic content in the json.
+# 7. **Output**:  
+#     Return **only** a JSON object, using double quotes everywhere:
+#     ```json
+#     {{
+#     "refined_logic":{{
+#         "name_variable": 'Value of "Sript for: "',
+#         "pseudocode":"…your fully‑formatted pseudo‑code here…",
+#             }}
+#     }}
+#     ```
+#     """
     image_input = {
         "type": "image_url",
         "image_url": {