Upload app.py

app.py

@@ -250,76 +250,6 @@ SYSTEM_PROMPT ="""Your task is to process OCR-extracted text from images of Scra
     - 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.
-# Your core task is to process game descriptions and existing Scratch JSON structures, then produce or update JSON segments accurately.
-# You possess deep knowledge of Scratch 3.0 project schema, informed by comprehensive reference materials. When generating or modifying the `blocks` section, pay extremely close attention to the following:
-
-# **Scratch Project JSON Schema Rules:**
-
-# 1.  **Target Structure (`project.json`'s `targets` array):**
-#     * Each object in the `targets` array represents a Stage or a Sprite.
-#     * `isStage`: A boolean indicating if the target is the Stage (`true`) or a Sprite (`false`).
-#     * `name`: The name of the Stage (e.g., `"Stage"`) or the Sprite (e.g., `"Cat"`). This property replaces `objName` found in older Scratch versions.
-#     * `variables` dictionary: This dictionary maps unique variable IDs to arrays `[variable_name, initial_value, isCloudVariable?]`.
-#         * `variable_name`: The user-defined name of the variable.
-#         * `initial_value`: The variable's initial value, which can be a number or a string.
-#         * `isCloudVariable?`: (Optional) A boolean indicating if it's a cloud variable (`true`) or a local variable (`false` or absent for regular variables).
-#         * Example: `"myVarId123": ["score", 0]`, `"cloudVarId456": ["☁ High Score", "54", true]`
-#     * `lists` dictionary: This dictionary maps unique list IDs to arrays `[list_name, [item1, item2, ...]]`.
-#         * Example: `"myListId789": ["my list", ["apple", "banana"]]`
-#     * `broadcasts` dictionary: This dictionary maps unique broadcast IDs to their names.
-#         * Example: `"myBroadcastId": "Game Over"`
-#     * `blocks` dictionary: This dictionary contains all the blocks belonging to this target. Keys are block IDs, values are block objects.
-
-# 2.  **Block Structure (within a `target`'s `blocks` dictionary):**
-#     * Every block object must have the following core properties:
-#         * [cite_start]`opcode`: A unique internal identifier for the block's specific functionality (e.g., `"motion_movesteps"`, `"event_whenflagclicked"`)[cite: 31, 18, 439, 452].
-#         * `parent`: The ID of the block directly above it in the script stack (or `null` for a top-level block).
-#         * `next`: The ID of the block directly below it in the script stack (or `null` for the end of a stack).
-#         * `inputs`: An object defining values or blocks plugged into the block's input slots. Values are **arrays**.
-#         * `fields`: An object defining dropdown menu selections or direct internal values within the block. Values are **arrays**.
-#         * `shadow`: `true` if it's a shadow block (e.g., a default number input that can be replaced by another block), `false` otherwise.
-#         * `topLevel`: `true` if it's a hat block or a standalone block (not connected to a parent), `false` otherwise.
-
-# 3.  **`inputs` Property Details (for blocks plugged into input slots):**
-#     * **Direct Block Connection (Reporter/Boolean block plugged in):**
-#         * Format: `"<INPUT_NAME>": [1, "<blockId_of_plugged_block>"]`
-#         * Example: `"CONDITION": [1, "someBooleanBlockId"]` (e.g., for an `if` block).
-#     * **Literal Value Input (Shadow block with a literal):**
-#         * Format: `"<INPUT_NAME>": [1, [<type_code>, "<value_string>"]]`
-#         * `type_code`: A numeric code representing the data type. Common codes include: `4` for number, `7` for string/text, `10` for string/message.
-#         * `value_string`: The literal value as a string.
-#         * Examples:
-#             * Number: `"STEPS": [1, [4, "10"]]` (for `move 10 steps` block).
-#             * String/Text: `"MESSAGE": [1, [7, "Hello"]]` (for `say Hello` block).
-#             * String/Message (common for text inputs): `"MESSAGE": [1, [10, "Hello!"]]` (for `say Hello! for 2 secs`).
-#     * **C-Block Substack (blocks within a loop or conditional):**
-#         * Format: `"<SUBSTACK_NAME>": [2, "<blockId_of_first_block_in_substack>"]`
-#         * Common `SUBSTACK_NAME` values are `SUBSTACK` (for `if`, `forever`, `repeat`) and `SUBSTACK2` (for `else` in `if else`).
-#         * Example: `"SUBSTACK": [2, "firstBlockInLoopId"]`
-
-# 4.  **`fields` Property Details (for dropdowns or direct internal values):**
-#     * Used for dropdown menus, variable names, list names, or other static selections directly within the block.
-#     * Format: `"<FIELD_NAME>": ["<selected_value>", null]`
-#     * Examples:
-#         * Dropdown: `"KEY_OPTION": ["space", null]` (for `when space key pressed`).
-#         * Variable Name: `"VARIABLE": ["score", null]` (for `set score to 0`).
-#         * Direction (specific motion block): `"FORWARD_BACKWARD": ["forward", null]` (for `go forward layers`).
-
-# 5.  **Unique IDs:**
-#     * All block IDs, variable IDs, and list IDs must be unique strings (e.g., "myBlock123", "myVarId456", "myListId789"). Do NOT use placeholder strings like "block_id_here".
-
-# 6.  **No Nested `blocks` Dictionary:**
-#     * The `blocks` dictionary should only appear once per `target` (sprite/stage). Do NOT nest a `blocks` dictionary inside an individual block definition. Blocks that are part of a substack are linked via the `SUBSTACK` input.
-
-# 7.  **Asset Properties (for Costumes/Sounds):**
-#     * `assetId`, `md5ext`, `bitmapResolution`, `rotationCenterX`/`rotationCenterY` should be correctly associated with costume and sound objects within the `costumes` and `sounds` arrays.
-
-# **General Principles and Important Considerations:**
-# * **Backward Compatibility:** Adhere strictly to existing Scratch 3.0 opcodes and schema to ensure backward compatibility with older projects. [cite_start]Opcodes must remain consistent to prevent previously saved projects from failing to load or behaving unexpectedly[cite: 18, 19, 25, 65].
-# * **Forgiving Inputs:** Recognize that Scratch is designed to be "forgiving in its interpretation of inputs." [cite_start]The Scratch VM handles potentially "invalid" inputs gracefully (e.g., converting a number to a string if expected, returning default values like zero or empty strings, or performing no action) rather than crashing[cite: 20, 21, 22, 38, 39, 41]. This implies that precise type matching for inputs might be handled internally by Scratch, allowing for some flexibility in how values are provided, but the agent should aim for the most common and logical type.
-# """
 
 # SYSTEM_PROMPT_JSON_CORRECTOR ="""
 # You are an assistant that outputs JSON responses strictly following the given schema.  
@@ -1700,822 +1630,6 @@ def node_optimizer(state: GameState):
     except Exception as e:
         logger.error(f"Error in Node Optimizer Node: {e}")
 
-# Node 2: planner node
-# def overall_planner_node(state: GameState):
-#     """
-#     Generates a comprehensive action plan for sprites, including detailed Scratch block information.
-#     This node acts as an overall planner, leveraging knowledge of all block shapes and categories.
-#     """
-#     logger.info("--- Running OverallPlannerNode ---")
-
-#     project_json = state["project_json"]
-#     raw = state.get("pseudo_code", {})
-#     refined_logic_data = raw.get("refined_logic", {})
-#     sprite_name = refined_logic_data.get("name_variable", "<unknown>")
-#     pseudo      = refined_logic_data.get("pseudocode", "")
-
-#     # MODIFICATION 1: Include 'Stage' in the list of names to plan for.
-#     # It's crucial to ensure 'Stage' is always present for its global role.
-#     target_names = [t["name"] for t in project_json["targets"]]
-
-#     # MODIFICATION 2: Get sprite positions, providing default for Stage as it doesn't have x,y
-#     sprite_positions = {}
-#     for target in project_json["targets"]:
-#         if not target["isStage"]:
-#             sprite_positions[target["name"]] = {"x": target.get("x", 0), "y": target.get("y", 0)}
-#         else:
-#             sprite_positions[target["name"]] = {"x": "N/A", "y": "N/A"} # Stage doesn't have positional coordinates
-
-#     # declaration_plan = state["declaration_plan"]
-
-#     planning_prompt = f"""
-# Generate a detailed action plan for the game's sprites and stage based on the given pseudo-code and sprite details for the given sprite name and .
-
-# Description: 
-#     **Sprite_name**: {sprite_name} 
-#     **and its corresponding Pseudo_code:** 
-#     '{pseudo}'
-
-# [Note: Make sure you just refine the pseudo code by correting mistake and adding the missing opcode if any and *Do not* generate any new logic]
-# ----
-# **Targets in Game (Sprites and Stage) available in project_json:** {', '.join(target_names)}
-
-# --- Scratch 3.0 Block Reference ---
-# This section provides a comprehensive reference of Scratch 3.0 blocks, categorized by shape, including their opcodes and functional descriptions. Use this to accurately identify block types and behavior.
-
-# ### 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  use the `Sprite_name` given and `Pseudo_code` and add it to the specific target name and define the primary actions and movements.
-# The output should be a JSON object with a single key 'action_overall_flow'. Each key inside this object should be a sprite or 'Stage' name (e.g., 'Player', 'Enemy', 'Stage'), and its value must include a 'description' and a list of 'plans'.
-# The first plan in each stage must start with one Scratch Hat Block (e.g., event_whenflagclicked).
-# Other plans may use any hat blocks (including duplicates) to represent different logics or events.
-# Each plan must include a **single Scratch Hat Block** (e.g., 'event_whenflagclicked') to start scratch project and should contain:
-
-# 1. **'event'**: the exact `opcode` of the hat block that initiates the logic.
-# [NOTE: INSTRUCTIONN TO FOLLOW IF PSEUDO_CODE HAVING PROBLEM ]
-# 2. **'logic'**: 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.
-#     - Use 'forever: ...' or 'repeat(10): ...' to prefix repeating logic suitable taking reference from the C blocks.
-#     - Use Scratch-consistent verbs: 'move', 'change', 'wait', 'hide', 'show', 'say', 'glide', etc.
-#     - **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.
-#    - **Indent nested blocks by 4 spaces under their parent (`forever`, `if`, etc.).This is a critical requirement.**
-# 3. **Opcode Lists**: include relevant Scratch opcodes grouped under `motion`, `control`, `operator`, `sensing`, `looks`, `sounds`, `events`, and `data`. List only the non-empty categories. Use exact opcodes.
-# 4. Few Example of content of logics inside for a specific plan as scratch pseudo-code:
-#     - example 1[continues moving objects]:
-#     ```
-#     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
-#     ```
-#     - example 2[jumping script of an plan]: 
-#     ```    
-#     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
-#     ```
-#    - example 3 [pattern for level up and increase difficulty]:
-#    ```
-#    when I receive [Level Up v]
-#        change [level v] by (1)
-#        set [ballSpeed v] to ((([ballSpeed v]) * (1.1)))
-#    end
-#    ```
-# 5. Use target names exactly as listed in `Targets in Game`. Do NOT rename or invent new targets.
-# 6. Ensure the plan reflects accurate opcode usage derived strictly from the block reference above.
-# 7. Few shot Example structure for 'action_overall_flow':
-# ```json
-# {{
-#     "action_overall_flow": {{
-#         "Stage": {{
-#             "description": "Background and global game state management, including broadcasts, rewards, and score.",
-#             "plans": [
-#                 {{
-#                     "event": "event_whenflagclicked",
-#                     "logic": "when green flag clicked\n    switch backdrop to [backdrop1 v]\n    set [score v] to 0\n    show variable [score v]\n    broadcast [Game Start v]\nend",
-#                     "motion": [],
-#                     "control": [],
-#                     "operator": [],
-#                     "sensing": [],
-#                     "looks": [
-#                         "looks_switchbackdropto"
-#                     ],
-#                     "sounds": [],
-#                     "events": [
-#                         "event_broadcast"
-#                     ],
-#                     "data": [
-#                         "data_setvariableto",
-#                         "data_showvariable"
-#                     ]
-#                 }},
-#                 {{
-#                     "event": "event_whenbroadcastreceived",
-#                     "logic": "when I receive [Game Over v]\n    if <(score) > (High Score)> then\n        set [High Score v] to (score)\n    end\n    switch backdrop to [HighScore v]\nend",
-#                     "motion": [],
-#                     "control": [
-#                         "control_if"
-#                     ],
-#                     "operator": [
-#                         "operator_gt"
-#                     ],
-#                     "sensing": [],
-#                     "looks": [
-#                         "looks_switchbackdropto"
-#                     ],
-#                     "sounds": [],
-#                     "events": [],
-#                     "data": [
-#                         "data_setvariableto"
-#                     ]
-#                 }}
-#             ]
-#         }},
-#         "Sprite1": {{
-#             "description": "Main character (cat) actions",
-#             "plans": [
-#                 {{
-#                     "event": "event_whenflagclicked",
-#                     "logic": "when green flag clicked\n    go to x: 240 y: -100\nend",
-#                     "motion": [
-#                         "motion_gotoxy"
-#                     ],
-#                     "control": [],
-#                     "operator": [],
-#                     "sensing": [],
-#                     "looks": [],
-#                     "sounds": [],
-#                     "events": [],
-#                     "data": []
-#                 }},
-#                 {{
-#                     "event": "event_whenkeypressed",
-#                     "logic": "when [space v] key pressed\n    repeat (10)\n        change y by (20)\n        wait (0.1) seconds\n        change y by (-20)\n    end\nend",
-#                     "motion": [
-#                         "motion_changeyby"
-#                     ],
-#                     "control": [
-#                         "control_repeat",
-#                         "control_wait"
-#                     ],
-#                     "operator": [],
-#                     "sensing": [],
-#                     "looks": [],
-#                     "sounds": [],
-#                     "events": [],
-#                     "data": []
-#                 }}
-#             ]
-#         }},
-#         "soccer ball": {{
-#             "description": "Obstacle movement and interaction",
-#             "plans": [
-#                 {{
-#                     "event": "event_whenflagclicked",
-#                     "logic": "when green flag clicked\n    go to x: 240 y: -135\n    forever\n        glide 2 seconds to x: -240 y: -135\n        if <(x position) < -235> then\n            set x to 240\n        end\n        if <touching [Sprite1 v]?> then\n            broadcast [Game Over v]\n            stop [all v]\n        end\n    end\nend",
-#                     "motion": [
-#                         "motion_gotoxy",
-#                         "motion_glidesecstoxy",
-#                         "motion_xposition",
-#                         "motion_setx"
-#                     ],
-#                     "control": [
-#                         "control_forever",
-#                         "control_if",
-#                         "control_stop"
-#                     ],
-#                     "operator": [
-#                         "operator_lt"
-#                     ],
-#                     "sensing": [
-#                         "sensing_touchingobject",
-#                         "sensing_touchingobjectmenu"
-#                     ],
-#                     "looks": [],
-#                     "sounds": [],
-#                     "events": [
-#                         "event_broadcast"
-#                     ],
-#                     "data": []
-#                 }}
-#             ]
-#         }}
-
-#     }}
-# }}
-# ```
-# 8.  Based on the provided context, generate the `action_overall_flow`.
-#     - Maintain the **exact JSON structure** shown above.
-#     - All `logic` fields must be **clear and granular**.
-#     - Only include opcode categories that contain relevant opcodes.
-#     - Ensure that each opcode matches its intended Scratch functionality.
-#     - If feedback suggests major change, **rethink the entire plan** for the affected sprite(s).
-#     - If feedback is minor, make precise, minimal improvements only.
-# """
-
-#     try:
-#         response = agent.invoke({"messages": [{"role": "user", "content": planning_prompt}]})
-#         print("Raw response from LLM [OverallPlannerNode 1]:",response)
-#         raw_response = response["messages"][-1].content#strip_noise(response["messages"][-1].content)
-#         print("Raw response from LLM [OverallPlannerNode 2]:", raw_response) # Uncomment for debugging
-#         # json debugging and solving
-#         try:
-#             overall_plan = extract_json_from_llm_response(raw_response)
-#         except json.JSONDecodeError as error_json:
-#             logger.error("Failed to extract JSON from LLM response. Attempting to correct the response.")
-#             # Use the JSON resolver agent to fix the response
-#             correction_prompt = (
-#                 "Your task is to correct the provided JSON string to ensure it is **syntactically perfect and adheres strictly to JSON rules**.\n"
-#                 "Carefully review the JSON for any errors, especially focusing on the reported error at:\n"
-#                 f"- **Error Details**: {error_json}\n\n"
-#                 "**Strict Instructions for your response:**\n"
-#                 "1. **ONLY** output the corrected JSON. Do not include any other text, comments, or explanations outside the JSON.\n"
-#                 "2. Ensure all property names (keys) are enclosed in **double quotes**.\n"
-#                 "3. Ensure string values are correctly enclosed in **double quotes** and any internal special characters (like newlines `\\n`, tabs `\\t`, backslashes `\\\\`, or double quotes `\\`) are properly **escaped**.\n"
-#                 "4. Verify that there are **no extra commas**, especially between key-value pairs or after the last element in an object or array.\n"
-#                 "5. Ensure proper nesting and matching of curly braces `{}` and square brackets `[]`.\n"
-#                 "6. **Crucially, remove any extraneous characters or duplicate closing braces outside the main JSON object.**\n"
-#                 "7. The corrected JSON must be a **complete and valid** JSON object.\n\n"
-#                 "Here is the problematic JSON string to correct:\n"
-#                 "```json\n"
-#                 f"{raw_response}\n"
-#                 "```\n"
-#                 "Corrected JSON:\n"
-#             )
-#             correction_response = agent_json_resolver.invoke({"messages": [{"role": "user", "content": correction_prompt}]})
-#             print(f"[JSON CORRECTOR RESPONSE AT OVERALLPLANNERNODE ]: {correction_response['messages'][-1].content}")
-#             overall_plan= extract_json_from_llm_response(correction_response['messages'][-1].content)#strip_noise(correction_response["messages"][-1].content))
-            
-#         state["action_plan"] = overall_plan
-#         logger.info("Overall plan generated by OverallPlannerNode.")
-        
-#         # with open("debug_state.json", "w", encoding="utf-8") as f:
-#         #     json.dump(state, f, indent=2, ensure_ascii=False)
-            
-#         return state
-            
-#     except Exception as e:
-#         logger.error(f"Error in OverallPlannerNode: {e}")
-#         raise
-# # Node 3: refiner node (scrape)
-# def refined_planner_node(state: GameState):
-#     """
-#     Refines the action plan based on validation feedback and game description.
-#     """
-#     logger.info("--- Running RefinedPlannerNode ---")
-#     raw = state.get("pseudo_code", {})
-#     refined_logic_data = raw.get("refined_logic", {})
-#     sprite_name = refined_logic_data.get("name_variable", "<unknown>")
-#     pseudo      = refined_logic_data.get("pseudocode", "")
-#     #detailed_game_description = state.get("detailed_game_description", state.get("description", "A game."))
-#     current_action_plan = state.get("action_plan", {})
-#     print(f"[current_action_plan before refinement] on ({state.get('iteration_count', 0)}): {json.dumps(current_action_plan, indent=2)}")
-#     plan_validation_feedback = state.get("plan_validation_feedback", "No specific feedback provided. Assume general refinement is needed.")
-#     project_json = state["project_json"]
-#     target_names = [t["name"] for t in project_json["targets"]]
-
-#     # MODIFICATION 2: Get sprite positions, providing default for Stage as it doesn't have x,y
-#     sprite_positions = {}
-#     for target in project_json["targets"]:
-#         if not target["isStage"]:
-#             sprite_positions[target["name"]] = {"x": target.get("x", 0), "y": target.get("y", 0)}
-#         else:
-#             sprite_positions[target["name"]] = {"x": "N/A", "y": "N/A"} # Stage doesn't have positional coordinates
-
-#     #declaration_plan = state["declaration_plan"]
-
-#     refinement_prompt = f"""
-# Refine and correct the JSON object `action_overall_flow` so that it fully aligns with the detailed game description, sprite positions, variable/broadcast declarations, and Scratch 3.0 block reference—while also validating for common formatting or opcode errors.
-
-# Here is the overall script available:
-# **Sprite name**: {sprite_name} 
-# **and its corresponding Pseudo_code:** 
-# '{pseudo}'
-
-# [Note: Make sure you just refine the pseudo code by correting mistake and adding the missing opcode if any and *Do not* generate any new logic]
-# ---
-# **Targets in Game (Sprites and Stage):** {', '.join(target_names)}  
-# **Current action plan:**  
-# {current_action_plan}
-
-# **Validation Feedback:**  
-# '{plan_validation_feedback}'
-
-# --- Scratch 3.0 Block Reference ---
-# ### Hat Blocks
-# {hat_opcodes_functionalities}
-
-# ### Boolean Blocks
-# {boolean_opcodes_functionalities}
-
-# ### C Blocks
-# {c_opcodes_functionalities}
-
-# ### Cap Blocks
-# {cap_opcodes_functionalities}
-
-# ### Reporter Blocks
-# {reporter_opcodes_functionalities}
-
-# ### Stack Blocks
-# {stack_opcodes_functionalities}
-
-# -----------------------------------
-
-# * **Your task is to align to description, refine and correct the JSON object 'action_overall_flow'.**
-# Use sprite names exactly as provided in `sprite_names` (e.g., 'Sprite1', 'soccer ball'); and also the stage, do **NOT** rename them.
-# Other plans may use any hat blocks (including duplicates) to represent different logics or events.
-# Each plan must include a **single Scratch Hat Block** (e.g., 'event_whenflagclicked') to start scratch project and should contain:
-# 1.  **'event'**: the exact `opcode` of the hat block that initiates the logic.
-# 2. **'logic'**: 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.
-#     - Do **NOT** include any justification or comments—only the raw logic.
-#     - Use 'forever: ...' or 'repeat(10): ...' to prefix repeating logic suitable taking reference from the C blocks.
-#     - Use Scratch-consistent verbs: 'move', 'change', 'wait', 'hide', 'show', 'say', 'glide', etc.
-#     - **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.
-# 3. **Validation & Formatting Checks**  
-#    - **Opcode Coverage**: Ensure every action in `logic` has a matching opcode in the lists.  
-#    - **Bracket Nesting**: Confirm every `(` has a matching `)`, e.g., `(pick random (100) to (-100))`.  
-#    - **Operator Formatting**: Validate that operators use Scratch operator blocks, not inline math.  
-#    - **Common Errors**:  
-#      - `pick random (100,-100)` → `(pick random (100) to (-100))`  
-#      - Missing `end` at script conclusion  
-#      - Unwrapped reporter inputs or Boolean tests
-# 4. **Opcode Lists**: include relevant Scratch opcodes grouped under `motion`, `control`, `operator`, `sensing`, `looks`, `sounds`, `events`, and `data`. List only the non-empty categories. Use exact opcodes from the given Scratch 3.0 Block Reference.
-# 5. Few Example of content of logics inside for a specific plan as scratch pseudo-code:
-#     - example 1[continues moving objects]:
-#     ```
-#     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
-#     ```
-#     - example 2[jumping script of an plan]: 
-#     ```    
-#     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
-#     ```
-#    - example 3 [pattern for level up and increase difficulty]:
-#    ```
-#    when I receive [Level Up v]
-#        change [level v] by (1)
-#        set [ballSpeed v] to ((([ballSpeed v]) * (1.1)))
-#    end
-#    ```
-# 6. Use target names exactly as listed in `Targets in Game`. Do NOT rename or invent new targets.
-# 7. Ensure the plan reflects accurate opcode usage derived strictly from the block reference above.
-# 8. Few shot Example structure for 'action_overall_flow':
-# ```json
-#     {{
-#     "action_overall_flow": {{
-#         "Stage": {{
-#             "description": "Background and global game state management, including broadcasts, rewards, and score.",
-#             "plans": [
-#                 {{
-#                     "event": "event_whenflagclicked",
-#                     "logic": "when green flag clicked\n    switch backdrop to [backdrop1 v]\n    set [score v] to 0\n    show variable [score v]\n    broadcast [Game Start v]\nend",
-#                     "motion": [],
-#                     "control": [],
-#                     "operator": [],
-#                     "sensing": [],
-#                     "looks": [
-#                         "looks_switchbackdropto"
-#                     ],
-#                     "sounds": [],
-#                     "events": [
-#                         "event_broadcast"
-#                     ],
-#                     "data": [
-#                         "data_setvariableto",
-#                         "data_showvariable"
-#                     ]
-#                 }},
-#                 {{
-#                     "event": "event_whenbroadcastreceived",
-#                     "logic": "when I receive [Game Over v]\n    if <(score) > (High Score)> then\n        set [High Score v] to (score)\n    end\n    switch backdrop to [HighScore v]\nend",
-#                     "motion": [],
-#                     "control": [
-#                         "control_if"
-#                     ],
-#                     "operator": [
-#                         "operator_gt"
-#                     ],
-#                     "sensing": [],
-#                     "looks": [
-#                         "looks_switchbackdropto"
-#                     ],
-#                     "sounds": [],
-#                     "events": [],
-#                     "data": [
-#                         "data_setvariableto"
-#                     ]
-#                 }}
-#             ]
-#         }},
-#         "Sprite1": {{
-#             "description": "Main character (cat) actions",
-#             "plans": [
-#                 {{
-#                     "event": "event_whenflagclicked",
-#                     "logic": "when green flag clicked\n    go to x: 240 y: -100\nend\n",
-#                     "motion": [
-#                         "motion_gotoxy"
-#                     ],
-#                     "control": [],
-#                     "operator": [],
-#                     "sensing": [],
-#                     "looks": [],
-#                     "sounds": [],
-#                     "events": [],
-#                     "data": []
-#                 }},
-#                 {{
-#                     "event": "event_whenkeypressed",
-#                     "logic": "when [space v] key pressed\n    repeat (10)\n        change y by (20)\n        wait (0.1) seconds\n        change y by (-20)\n    end\nend",
-#                     "motion": [
-#                         "motion_changeyby"
-#                     ],
-#                     "control": [
-#                         "control_repeat",
-#                         "control_wait"
-#                     ],
-#                     "operator": [],
-#                     "sensing": [],
-#                     "looks": [],
-#                     "sounds": [],
-#                     "events": [],
-#                     "data": []
-#                 }}
-#             ]
-#         }},
-#         "soccer ball": {{
-#             "description": "Obstacle movement and interaction",
-#             "plans": [
-#                 {{
-#                     "event": "event_whenflagclicked",
-#                     "logic": "when green flag clicked\n    go to x: 240 y: -135\n    forever\n        glide 2 seconds to x: -240 y: -135\n        if <(x position) < -235> then\n            set x to 240\n        end\n        if <touching [Sprite1 v]?> then\n            broadcast [Game Over v]\n            stop [all v]\n        end\n    end\nend",
-#                     "motion": [
-#                         "motion_gotoxy",
-#                         "motion_glidesecstoxy",
-#                         "motion_xposition",
-#                         "motion_setx"
-#                     ],
-#                     "control": [
-#                         "control_forever",
-#                         "control_if",
-#                         "control_stop"
-#                     ],
-#                     "operator": [
-#                         "operator_lt"
-#                     ],
-#                     "sensing": [
-#                         "sensing_touchingobject",
-#                         "sensing_touchingobjectmenu"
-#                     ],
-#                     "looks": [],
-#                     "sounds": [],
-#                     "events": [
-#                         "event_broadcast"
-#                     ],
-#                     "data": []
-#                 }}
-#             ]
-#         }}
-#     }}
-# }}
-# ```
-# 9. Use the validation feedback to address errors, fill in missing logic, or enhance clarity.
-#     example of few possible improvements: 1.event_whenflagclicked is used to control sprite but its used for actual start scratch project and reset scratch. 2. looping like forever used where we should use iterative. 3. missing of for variable we used in the block
-#     - Maintain the **exact JSON structure** shown above.
-#     - All `logic` fields must be **clear and granular**.
-#     - Only include opcode categories that contain relevant opcodes.
-#     - Ensure that each opcode matches its intended Scratch functionality.
-#     - If feedback suggests major change, **rethink the entire plan** for the affected sprite(s).
-#     - If feedback is minor, make precise, minimal improvements only.
-# """
-#     try:
-#         response = agent.invoke({"messages": [{"role": "user", "content": refinement_prompt}]})
-#         raw_response = response["messages"][-1].content#strip_noise(response["messages"][-1].content)
-#         logger.info(f"Raw response from LLM [RefinedPlannerNode]: {raw_response[:500]}...")
-#         # json debugging and solving
-#         try:
-#             refined_plan = extract_json_from_llm_response(raw_response)
-#         except json.JSONDecodeError as error_json:
-#             logger.error("Failed to extract JSON from LLM response. Attempting to correct the response.")
-#             # Use the JSON resolver agent to fix the response
-#             correction_prompt = (
-#                 "Your task is to correct the provided JSON string to ensure it is **syntactically perfect and adheres strictly to JSON rules**.\n"
-#                 "Carefully review the JSON for any errors, especially focusing on the reported error at:\n"
-#                 f"- **Error Details**: {error_json}\n\n"
-#                 "**Strict Instructions for your response:**\n"
-#                 "1. **ONLY** output the corrected JSON. Do not include any other text, comments, or explanations outside the JSON.\n"
-#                 "2. Ensure all property names (keys) are enclosed in **double quotes**.\n"
-#                 "3. Ensure string values are correctly enclosed in **double quotes** and any internal special characters (like newlines `\\n`, tabs `\\t`, backslashes `\\\\`, or double quotes `\\`) are properly **escaped**.\n"
-#                 "4. IN `logic` field make sure content enclosed in **double quotes** should not have invalid **double quotes**, **eliminate** all quotes inside the content if any. "
-#                 "4. Verify that there are **no extra commas**, especially between key-value pairs or after the last element in an object or array.\n"
-#                 "5. Ensure proper nesting and matching of curly braces `{}` and square brackets `[]`.\n"
-#                 "6. **Crucially, remove any extraneous characters or duplicate closing braces outside the main JSON object.**\n" # Added instruction
-#                 "7. The corrected JSON must be a **complete and valid** JSON object.\n\n"
-#                 "Here is the problematic JSON string to correct:\n"
-#                 "```json\n"
-#                 f"{raw_response}\n"
-#                 "```\n"
-#                 "Corrected JSON:\n"
-#             )
-#             correction_response = agent_json_resolver.invoke({"messages": [{"role": "user", "content": correction_prompt}]})
-#             print(f"[JSON CORRECTOR RESPONSE AT REFINEPLANNER ]: {correction_response['messages'][-1].content}")
-#             refined_plan = extract_json_from_llm_response(correction_response["messages"][-1].content)#strip_noise(correction_response["messages"][-1].content))
-#             logger.info("Refined plan corrected by JSON resolver agent.")
-            
-#         if refined_plan:
-#             #state["action_plan"] = refined_plan.get("action_overall_flow", {}) # Update to the key 'action_overall_flow' [error]
-#             state["action_plan"] = refined_plan #.get("action_overall_flow", {})  # Update the main the prompt includes updated only
-#             logger.info("Action plan refined by RefinedPlannerNode.")
-#         else:
-#             logger.warning("RefinedPlannerNode did not return a valid 'action_overall_flow' structure. Keeping previous plan.")
-#         print("[Refined Action Plan]:", json.dumps(state["action_plan"], indent=2))
-#         #print("[current state after refinement]:", json.dumps(state, indent=2))
-        
-#         # with open("debug_state.json", "w", encoding="utf-8") as f:
-#         #     json.dump(state, f, indent=2, ensure_ascii=False)
-        
-#         return state
-#     except Exception as e:
-#         logger.error(f"Error in RefinedPlannerNode: {e}")
-#         raise
-# # Node 4: opcode counter node (scrape)
-# def plan_opcode_counter_node(state: Dict[str, Any]) -> Dict[str, Any]:
-#     """
-#     For each plan in state["action_plan"], calls the LLM agent
-#     to analyze the `logic` string and return a list of {opcode, count} for each category.
-#     """
-#     logger.info("=== Running OPCODE COUTER LOGIC with LLM counts ===")
-#     #game_description = state.get("description", "No game description provided.")
-#     sprite_name = {}
-#     project_json_targets = state.get("project_json", {}).get("targets", [])
-#     for target in project_json_targets:
-#         sprite_name[target["name"]] = target["name"]
-    
-#     action_flow = state.get("action_plan", {}) 
-    
-#     if action_flow.get("action_overall_flow", {}) == {}:
-#         plan_data = action_flow.items()
-#     else:
-#         plan_data = action_flow.get("action_overall_flow", {}).items()
-    
-#     refined_flow: Dict[str, Any] = {}
-#     for sprite, sprite_data in plan_data:
-#         refined_plans = []
-#         for plan in sprite_data.get("plans", []):
-#             logic = plan.get("logic", "")
-#             event = plan.get("event", "")
-            
-#             # These are for guiding the LLM, not for the final output format directly
-#             opcodes_from_plan = {
-#                 "motion": plan.get("motion", []),
-#                 "control": plan.get("control", []),
-#                 "operator": plan.get("operator", []),
-#                 "sensing": plan.get("sensing", []),
-#                 "looks": plan.get("looks", []),
-#                 "sounds": plan.get("sounds", []),
-#                 "events": plan.get("events", []) + ([event] if isinstance(event, str) else []),
-#                 "data": plan.get("data", []),
-#             }
-
-#             refinement_prompt = f"""
-# You are a Scratch 3.0 expert with deep knowledge of block types, nesting and stack relationships.
-# Your job: read the plan logic below and decide exactly which blocks (and how many of each) are required to implement it.
-# Review the following plan for '{sprite}' triggered by '{event}'.
-# --- 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}
-# -----------------------------------
-# Current Plan Details:
-# - Event (Hat Block Opcode): {event}
-# - Associated Opcodes by Category: {json.dumps(opcodes_from_plan, indent=2)}
-
-# ── Game Context ──
-# Sprite: "{sprite}"
-
-# ── Current Plan ──
-# Event (hat block): {event}
-# Logic (pseudo-Scratch): {logic}
-# Plan : {plan}
-
-# ── Opcode Candidates ──
-# Motion:   {opcodes_from_plan["motion"]}
-# Control:  {opcodes_from_plan["control"]}
-# Operator: {opcodes_from_plan["operator"]}
-# Sensing:  {opcodes_from_plan["sensing"]}
-# Looks:    {opcodes_from_plan["looks"]}
-# Sounds:   {opcodes_from_plan["sounds"]}
-# Events:   {opcodes_from_plan["events"]}
-# Data:     {opcodes_from_plan["data"]}
-
-# ── Your Task ──
-# 1. Analyze the “Logic” steps and choose exactly which opcodes are needed. 
-# 2. Use exact opcodes from the given Scratch 3.0 Block Reference and verfiy the proper opcode are used available in the Scratch 3.0 Block Reference.
-# 3. Return a top-level JSON object with a single key: "opcode_counts".
-# 4. The value of "opcode_counts" should be a list of objects, where each object has "opcode": "<opcode_name>" and "count": <integer>.
-# 5. Ensure the list includes the hat block for this plan (e.g., event_whenflagclicked, event_whenkeypressed, event_whenbroadcastreceived) with a count of 1.
-# 6. The order of opcodes within the "opcode_counts" list does not matter.
-# 7. If any plan logic is None do not generate the opcode_counts for it.
-# 8. Use only double quotes and ensure valid JSON.
-
-# Example output:
-# **example 1**
-# ```json    
-# {{
-# "opcode_counts":[
-#     {{"opcode":"motion_gotoxy","count":1}},
-#     {{"opcode":"control_forever","count":1}},
-#     {{"opcode":"control_if","count":1}},
-#     {{"opcode":"looks_switchbackdropto","count":1}},
-#     {{"opcode":"event_whenflagclicked","count":1}},
-#     {{"opcode":"event_broadcast","count":1}},
-#     {{"opcode":"data_setvariableto","count":2}},
-#     {{"opcode":"data_showvariable","count":2}}
-#     ]        
-# }}    
-# ```
-# **example 2**
-# ```json    
-# {{        
-# "opcode_counts":[
-#     {{"opcode":"motion_gotoxy","count":1}},
-#     {{"opcode":"motion_glidesecstoxy","count":1}},
-#     {{"opcode":"motion_xposition","count":1}},
-#     {{"opcode":"motion_setx","count":1}},
-#     {{"opcode":"control_forever","count":1}},
-#     {{"opcode":"control_if","count":2}},
-#     {{"opcode":"operator_lt","count":1}},
-#     {{"opcode":"sensing_touchingobject","count":1}},
-#     {{"opcode":"event_whenflagclicked","count":1}},
-#     {{"opcode":"event_broadcast","count":1}}
-#     ]
-# }}
-# ```
-# """                                    
-#             try:
-#                 response = agent.invoke({"messages": [{"role": "user", "content": refinement_prompt}]})
-#                 llm_output = response["messages"][-1].content
-#                 llm_json = extract_json_from_llm_response(llm_output)                 
-#                 logger.info(f"Successfully analyze the opcode requirement for {sprite} - {event}.")
-
-#             except json.JSONDecodeError as error_json:
-#                 logger.error(f"JSON Decode Error for {sprite} - {event}: {error_json}. Attempting correction.")
-#                 correction_prompt = (
-#                     "Your task is to correct the provided JSON string to ensure it is **syntactically perfect and adheres strictly to JSON rules**.\n"
-#                     "It must be a JSON object with a single key `opcode_counts` containing a list of objects like {{'opcode': '<opcode_name>', 'count': <integer>}}.\n"
-#                     f"- **Error Details**: {error_json}\n\n"
-#                     "**Strict Instructions for your response:**\n"
-#                     "1. **ONLY** output the corrected JSON. Do not include any other text or explanations.\n"
-#                     "2. Ensure all keys and string values are enclosed in **double quotes**. Escape internal quotes (`\\`).\n"
-#                     "3. No trailing commas. Correct nesting.\n\n"
-#                     "Here is the problematic JSON string to correct:\n"
-#                     f"```json\n{llm_output}\n```\n"
-#                     "Corrected JSON:\n"
-#                 )
-#                 try:
-#                     correction_response = agent_json_resolver.invoke({"messages": [{"role": "user", "content": correction_prompt}]})
-#                     llm_json = extract_json_from_llm_response(correction_response["messages"][-1].content)
-#                     logger.info(f"Successfully corrected JSON output for {sprite} - {event}.")
-#                 except Exception as e_corr:
-#                     logger.error(f"Failed to correct JSON output for {sprite} - {event} even after retry: {e_corr}")
-#                     continue 
-
-#             # Directly use the 'opcode_counts' list from the LLM's output
-#             plan["opcode_counts"] = llm_json.get("opcode_counts", [])
-#             plan["opcode_counts"] = validate_and_fix_opcodes(plan["opcode_counts"])
-#             # Optionally, you can remove the individual category lists from the plan
-#             # if they are no longer needed after the LLM provides the consolidated list.
-#             # for key in ["motion", "control", "operator", "sensing", "looks", "sounds", "events", "data"]:
-#             #     if key in plan:
-#             #         del plan[key]
-
-#             refined_plans.append(plan)
-
-#         refined_flow[sprite] = {
-#             "description": sprite_data.get("description", ""),
-#             "plans": refined_plans
-#         }
-    
-#     if refined_flow:
-#         state["action_plan"] = refined_flow
-#         logger.info("logic aligned by logic_aligner_Node.")
-        
-#     state["temporary_node"] = refined_flow
-#     #state["temporary_node"] = refined_flow
-#     print(f"[OPCODE COUTER LOGIC]: {refined_flow}")
-#     logger.info("=== OPCODE COUTER LOGIC completed ===")
-#     return state
-
 # Node 5: block_builder_node
 def overall_block_builder_node_2(state: GameState):
     logger.info("--- Running OverallBlockBuilderNode ---")