Update app.py

app.py

@@ -136,126 +136,126 @@ for d in (
 #     pseudo_code: dict
 #     action_plan: Optional[Dict]
 #     temporary_node: Optional[Dict]
-class GameState(TypedDict):
-    image: str
-    pseudo_node: Optional[Dict]
+# class GameState(TypedDict):
+#     image: str
+#     pseudo_node: Optional[Dict]
     
-# Refined SYSTEM_PROMPT with more explicit Scratch JSON rules, especially for variables
-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.  
-If the JSON you produce has any formatting errors, missing required fields, or invalid structure, you must identify the problems and correct them.  
-Always return only valid JSON that fully conforms to the schema below, enclosed in triple backticks (```), without any extra text or explanation.  
-
-If you receive an invalid or incomplete JSON response, fix it by:  
-- Adding any missing required fields with appropriate values.  
-- Correcting syntax errors such as missing commas, brackets, or quotes.  
-- Ensuring the JSON structure matches the schema exactly.  
-
-Remember: Your output must be valid JSON only, ready to be parsed without errors.
-"""
-# debugger and resolver agent for Scratch 3.0
-# Main agent of the system agent for Scratch 3.0
-agent = create_react_agent(
-    model=llm,
-    tools=[], # No specific tools are defined here, but could be added later
-    prompt=SYSTEM_PROMPT
-)
+# # Refined SYSTEM_PROMPT with more explicit Scratch JSON rules, especially for variables
+# 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.
+# """
 
-agent_json_resolver = create_react_agent(
-    model=llm,
-    tools=[], # No specific tools are defined here, but could be added later
-    prompt=SYSTEM_PROMPT_JSON_CORRECTOR 
-)
+# SYSTEM_PROMPT_JSON_CORRECTOR ="""
+# You are an assistant that outputs JSON responses strictly following the given schema.  
+# If the JSON you produce has any formatting errors, missing required fields, or invalid structure, you must identify the problems and correct them.  
+# Always return only valid JSON that fully conforms to the schema below, enclosed in triple backticks (```), without any extra text or explanation.  
 
-# Helper function to load the block catalog from a JSON file
-def _load_block_catalog(file_path: str) -> Dict:
-    """Loads the Scratch block catalog from a specified JSON file."""
-    try:
-        with open(file_path, 'r') as f:
-            catalog = json.load(f)
-        logger.info(f"Successfully loaded block catalog from {file_path}")
-        return catalog
-    except FileNotFoundError:
-        logger.error(f"Error: Block catalog file not found at {file_path}")
-        # Return an empty dict or raise an error, depending on desired behavior
-        return {}
-    except json.JSONDecodeError as e:
-        logger.error(f"Error decoding JSON from {file_path}: {e}")
-        return {}
-    except Exception as e:
-        logger.error(f"An unexpected error occurred while loading {file_path}: {e}")
-        return {}
+# If you receive an invalid or incomplete JSON response, fix it by:  
+# - Adding any missing required fields with appropriate values.  
+# - Correcting syntax errors such as missing commas, brackets, or quotes.  
+# - Ensuring the JSON structure matches the schema exactly.  
+
+# Remember: Your output must be valid JSON only, ready to be parsed without errors.
+# """
+# debugger and resolver agent for Scratch 3.0
+# Main agent of the system agent for Scratch 3.0
+# agent = create_react_agent(
+#     model=llm,
+#     tools=[], # No specific tools are defined here, but could be added later
+#     prompt=SYSTEM_PROMPT
+# )
+
+# agent_json_resolver = create_react_agent(
+#     model=llm,
+#     tools=[], # No specific tools are defined here, but could be added later
+#     prompt=SYSTEM_PROMPT_JSON_CORRECTOR 
+# )
+
+# # Helper function to load the block catalog from a JSON file
+# def _load_block_catalog(file_path: str) -> Dict:
+#     """Loads the Scratch block catalog from a specified JSON file."""
+#     try:
+#         with open(file_path, 'r') as f:
+#             catalog = json.load(f)
+#         logger.info(f"Successfully loaded block catalog from {file_path}")
+#         return catalog
+#     except FileNotFoundError:
+#         logger.error(f"Error: Block catalog file not found at {file_path}")
+#         # Return an empty dict or raise an error, depending on desired behavior
+#         return {}
+#     except json.JSONDecodeError as e:
+#         logger.error(f"Error decoding JSON from {file_path}: {e}")
+#         return {}
+#     except Exception as e:
+#         logger.error(f"An unexpected error occurred while loading {file_path}: {e}")
+#         return {}
 
 # Helper function to load the block catalog from a JSON file
 # def _load_block_catalog(block_type: str) -> Dict:
@@ -303,191 +303,190 @@ def _load_block_catalog(file_path: str) -> Dict:
 
 
 # --- Global variable for the block catalog ---
-ALL_SCRATCH_BLOCKS_CATALOG = {}
-# BLOCK_CATALOG_PATH = "blocks" # Define the path to your JSON file
-# HAT_BLOCKS_PATH = "hat_blocks" # Path to the hat blocks JSON file
-# STACK_BLOCKS_PATH = "stack_blocks" # Path to the stack blocks JSON file
-# REPORTER_BLOCKS_PATH = "reporter_blocks" # Path to the reporter blocks JSON file
-# BOOLEAN_BLOCKS_PATH = "boolean_blocks" # Path to the boolean blocks JSON file
-# C_BLOCKS_PATH = "c_blocks" # Path to the C blocks JSON file
-# CAP_BLOCKS_PATH = "cap_blocks" # Path to the cap blocks JSON file
-
-BLOCK_CATALOG_PATH = BLOCKS_DIR / "blocks.json" 
-HAT_BLOCKS_PATH = BLOCKS_DIR / "hat_blocks.json" 
-STACK_BLOCKS_PATH = BLOCKS_DIR / "stack_blocks.json"
-REPORTER_BLOCKS_PATH = BLOCKS_DIR / "reporter_blocks.json" 
-BOOLEAN_BLOCKS_PATH = BLOCKS_DIR / "boolean_blocks.json" 
-C_BLOCKS_PATH = BLOCKS_DIR / "c_blocks.json" 
-CAP_BLOCKS_PATH = BLOCKS_DIR / "cap_blocks.json"
-
-# Load the block catalogs from their respective JSON files
-hat_block_data = _load_block_catalog(HAT_BLOCKS_PATH)
-hat_description = hat_block_data["description"]
-# hat_description = hat_block_data.get("description", "No description available")
-# hat_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in hat_block_data["blocks"]])
-# hat_opcodes_functionalities = "\n".join([
-#     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
-#     for block in hat_block_data.get("blocks", [])
-# ]) if isinstance(hat_block_data.get("blocks"), list) else "    No blocks information available."
-hat_opcodes_functionalities = os.path.join(BLOCKS_DIR, "hat_blocks.txt")
-print("Hat blocks loaded successfully.", hat_description)
-
-boolean_block_data = _load_block_catalog(BOOLEAN_BLOCKS_PATH)
-boolean_description = boolean_block_data["description"]
-# boolean_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in boolean_block_data["blocks"]])
-# boolean_opcodes_functionalities = "\n".join([
-#     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
-#     for block in boolean_block_data.get("blocks", [])
-# ]) if isinstance(boolean_block_data.get("blocks"), list) else "    No blocks information available."
-boolean_opcodes_functionalities = os.path.join(BLOCKS_DIR, "boolean_blocks.txt")
-
-c_block_data = _load_block_catalog(C_BLOCKS_PATH)
-c_description = c_block_data["description"]
-# c_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in c_block_data["blocks"]])
-# c_opcodes_functionalities = "\n".join([
-#     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
-#     for block in c_block_data.get("blocks", [])
-# ]) if isinstance(c_block_data.get("blocks"), list) else "    No blocks information available."
-c_opcodes_functionalities = os.path.join(BLOCKS_DIR, "c_blocks.txt")
-
-cap_block_data = _load_block_catalog(CAP_BLOCKS_PATH)
-cap_description = cap_block_data["description"]                                                                                                                                                                                                                                                                                                                                                                                                                                                      
-# cap_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in cap_block_data["blocks"]])
-# cap_opcodes_functionalities = "\n".join([
-#     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
-#     for block in cap_block_data.get("blocks", [])
-# ]) if isinstance(cap_block_data.get("blocks"), list) else "    No blocks information available."
-cap_opcodes_functionalities = os.path.join(BLOCKS_DIR, "cap_blocks.txt")
-
-reporter_block_data = _load_block_catalog(REPORTER_BLOCKS_PATH)
-reporter_description = reporter_block_data["description"]
-# reporter_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in reporter_block_data["blocks"]])
-# reporter_opcodes_functionalities = "\n".join([
-#     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
-#     for block in reporter_block_data.get("blocks", [])
-# ]) if isinstance(reporter_block_data.get("blocks"), list) else "    No blocks information available."
-reporter_opcodes_functionalities = os.path.join(BLOCKS_DIR, "reporter_blocks.txt")
-
-stack_block_data = _load_block_catalog(STACK_BLOCKS_PATH)
-stack_description = stack_block_data["description"]
-# stack_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in stack_block_data["blocks"]])
-# stack_opcodes_functionalities = "\n".join([
-#     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
-#     for block in stack_block_data.get("blocks", [])
-# ]) if isinstance(stack_block_data.get("blocks"), list) else "    No blocks information available."
-stack_opcodes_functionalities = os.path.join(BLOCKS_DIR, "stack_blocks.txt")
-
-# This makes ALL_SCRATCH_BLOCKS_CATALOG available globally
-# ALL_SCRATCH_BLOCKS_CATALOG = _load_block_catalog(BLOCK_CATALOG_PATH)
-
-# Helper function to extract JSON from LLM response
-def extract_json_from_llm_response(raw_response: str) -> dict:
-    # --- 1) Pull out the JSON code‑block if present ---
-    md = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", raw_response)
-    json_string = md.group(1).strip() if md else raw_response
-
-    # --- 2) Trim to the outermost { … } so we drop any prefix/suffix junk ---
-    first, last = json_string.find('{'), json_string.rfind('}')
-    if 0 <= first < last:
-        json_string = json_string[first:last+1]
-
-    # --- 3) PRE‑CLEANUP: remove stray assistant{…}, rogue assistant keys, fix boolean quotes ---
-    json_string = re.sub(r'\b\w+\s*{', '{', json_string)
-    json_string = re.sub(r'"assistant"\s*:', '', json_string)
-    json_string = re.sub(r'\b(false|true)"', r'\1', json_string)
-    logger.debug("Ran pre‑cleanup for stray tokens and boolean quotes.")
-
-    # --- 3.1) Fix stray inner quotes at start of name/list values ---
-    # e.g., { "name": " \"recent_scoress\"", ... } → "recent_scoress"
-    json_string = re.sub(
-        r'("name"\s*:\s*")\s*"',
-        r'\1',
-        json_string
-    )
-
-    # --- 4) Escape all embedded quotes in any `logic` value up to the next key ---
-    def _esc(m):
-        prefix, body = m.group(1), m.group(2)
-        return prefix + body.replace('"', r'\"')
-    json_string = re.sub(
-        r'("logic"\s*:\s*")([\s\S]+?)(?=",\s*"[A-Za-z_]\w*"\s*:\s*)',
-        _esc,
-        json_string
-    )
-    logger.debug("Escaped embedded quotes in logic fields.")
-
-    logger.debug("Quoted unquoted keys.")
-
-    # --- 6) Remove trailing commas before } or ] ---
-    json_string = re.sub(r',\s*(?=[}\],])', '', json_string)
-    json_string = re.sub(r',\s*,', ',', json_string)
-    logger.debug("Removed trailing commas.")
-
-    # --- 7) Balance braces: drop extra } at end if needed ---
-    ob, cb = json_string.count('{'), json_string.count('}')
-    if cb > ob:
-        excess = cb - ob
-        json_string = json_string.rstrip()[:-excess]
-        logger.debug(f"Stripped {excess} extra closing brace(s).")
-
-    # --- 8) Escape literal newlines in *all* string values ---
-    json_string = re.sub(
-        r'"((?:[^"\\]|\\.)*?)"',
-        lambda m: '"' + m.group(1).replace('\n', '\\n').replace('\r', '\\r') + '"',
-        json_string,
-        flags=re.DOTALL
-    )
-    logger.debug("Escaped newlines in strings.")
-
-    # --- 9) Final parse attempt ---
-    try:
-        return json.loads(json_string)
-    except json.JSONDecodeError:
-        logger.error("Sanitized JSON still invalid:\n%s", json_string)
-        raise
-
-def clean_base64_for_model(raw_b64):
-    """
-    Normalize input into a valid data:image/png;base64,<payload> string.
+# ALL_SCRATCH_BLOCKS_CATALOG = {}
+# # BLOCK_CATALOG_PATH = "blocks" # Define the path to your JSON file
+# # HAT_BLOCKS_PATH = "hat_blocks" # Path to the hat blocks JSON file
+# # STACK_BLOCKS_PATH = "stack_blocks" # Path to the stack blocks JSON file
+# # REPORTER_BLOCKS_PATH = "reporter_blocks" # Path to the reporter blocks JSON file
+# # BOOLEAN_BLOCKS_PATH = "boolean_blocks" # Path to the boolean blocks JSON file
+# # C_BLOCKS_PATH = "c_blocks" # Path to the C blocks JSON file
+# # CAP_BLOCKS_PATH = "cap_blocks" # Path to the cap blocks JSON file
+
+# BLOCK_CATALOG_PATH = BLOCKS_DIR / "blocks.json" 
+# HAT_BLOCKS_PATH = BLOCKS_DIR / "hat_blocks.json" 
+# STACK_BLOCKS_PATH = BLOCKS_DIR / "stack_blocks.json"
+# REPORTER_BLOCKS_PATH = BLOCKS_DIR / "reporter_blocks.json" 
+# BOOLEAN_BLOCKS_PATH = BLOCKS_DIR / "boolean_blocks.json" 
+# C_BLOCKS_PATH = BLOCKS_DIR / "c_blocks.json" 
+# CAP_BLOCKS_PATH = BLOCKS_DIR / "cap_blocks.json"
+
+# # Load the block catalogs from their respective JSON files
+# hat_block_data = _load_block_catalog(HAT_BLOCKS_PATH)
+# hat_description = hat_block_data["description"]
+# # hat_description = hat_block_data.get("description", "No description available")
+# # hat_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in hat_block_data["blocks"]])
+# # hat_opcodes_functionalities = "\n".join([
+# #     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
+# #     for block in hat_block_data.get("blocks", [])
+# # ]) if isinstance(hat_block_data.get("blocks"), list) else "    No blocks information available."
+# hat_opcodes_functionalities = os.path.join(BLOCKS_DIR, "hat_blocks.txt")
+# print("Hat blocks loaded successfully.", hat_description)
+
+# boolean_block_data = _load_block_catalog(BOOLEAN_BLOCKS_PATH)
+# boolean_description = boolean_block_data["description"]
+# # boolean_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in boolean_block_data["blocks"]])
+# # boolean_opcodes_functionalities = "\n".join([
+# #     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
+# #     for block in boolean_block_data.get("blocks", [])
+# # ]) if isinstance(boolean_block_data.get("blocks"), list) else "    No blocks information available."
+# boolean_opcodes_functionalities = os.path.join(BLOCKS_DIR, "boolean_blocks.txt")
+
+# c_block_data = _load_block_catalog(C_BLOCKS_PATH)
+# c_description = c_block_data["description"]
+# # c_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in c_block_data["blocks"]])
+# # c_opcodes_functionalities = "\n".join([
+# #     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
+# #     for block in c_block_data.get("blocks", [])
+# # ]) if isinstance(c_block_data.get("blocks"), list) else "    No blocks information available."
+# c_opcodes_functionalities = os.path.join(BLOCKS_DIR, "c_blocks.txt")
+
+# cap_block_data = _load_block_catalog(CAP_BLOCKS_PATH)
+# cap_description = cap_block_data["description"]                                                                                                                                                                                                                                                                                                                                                                                                                                                      
+# # cap_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in cap_block_data["blocks"]])
+# # cap_opcodes_functionalities = "\n".join([
+# #     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
+# #     for block in cap_block_data.get("blocks", [])
+# # ]) if isinstance(cap_block_data.get("blocks"), list) else "    No blocks information available."
+# cap_opcodes_functionalities = os.path.join(BLOCKS_DIR, "cap_blocks.txt")
+
+# reporter_block_data = _load_block_catalog(REPORTER_BLOCKS_PATH)
+# reporter_description = reporter_block_data["description"]
+# # reporter_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in reporter_block_data["blocks"]])
+# # reporter_opcodes_functionalities = "\n".join([
+# #     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
+# #     for block in reporter_block_data.get("blocks", [])
+# # ]) if isinstance(reporter_block_data.get("blocks"), list) else "    No blocks information available."
+# reporter_opcodes_functionalities = os.path.join(BLOCKS_DIR, "reporter_blocks.txt")
+
+# stack_block_data = _load_block_catalog(STACK_BLOCKS_PATH)
+# stack_description = stack_block_data["description"]
+# # stack_opcodes_functionalities = "\n".join([f"    - Opcode: {block['op_code']}, functionality: {block['functionality']} example: standalone use: {block['example_standalone']}" for block in stack_block_data["blocks"]])
+# # stack_opcodes_functionalities = "\n".join([
+# #     f"    - Opcode: {block.get('op_code', 'N/A')}, functionality: {block.get('functionality', 'N/A')}, example: standalone use {block.get('example_standalone', 'N/A')}"
+# #     for block in stack_block_data.get("blocks", [])
+# # ]) if isinstance(stack_block_data.get("blocks"), list) else "    No blocks information available."
+# stack_opcodes_functionalities = os.path.join(BLOCKS_DIR, "stack_blocks.txt")
+
+# # This makes ALL_SCRATCH_BLOCKS_CATALOG available globally
+# # ALL_SCRATCH_BLOCKS_CATALOG = _load_block_catalog(BLOCK_CATALOG_PATH)
+
+# # Helper function to extract JSON from LLM response
+# def extract_json_from_llm_response(raw_response: str) -> dict:
+#     # --- 1) Pull out the JSON code‑block if present ---
+#     md = re.search(r"```(?:json)?\s*([\s\S]*?)\s*```", raw_response)
+#     json_string = md.group(1).strip() if md else raw_response
+
+#     # --- 2) Trim to the outermost { … } so we drop any prefix/suffix junk ---
+#     first, last = json_string.find('{'), json_string.rfind('}')
+#     if 0 <= first < last:
+#         json_string = json_string[first:last+1]
+
+#     # --- 3) PRE‑CLEANUP: remove stray assistant{…}, rogue assistant keys, fix boolean quotes ---
+#     json_string = re.sub(r'\b\w+\s*{', '{', json_string)
+#     json_string = re.sub(r'"assistant"\s*:', '', json_string)
+#     json_string = re.sub(r'\b(false|true)"', r'\1', json_string)
+#     logger.debug("Ran pre‑cleanup for stray tokens and boolean quotes.")
+
+#     # --- 3.1) Fix stray inner quotes at start of name/list values ---
+#     # e.g., { "name": " \"recent_scoress\"", ... } → "recent_scoress"
+#     json_string = re.sub(
+#         r'("name"\s*:\s*")\s*"',
+#         r'\1',
+#         json_string
+#     )
+
+#     # --- 4) Escape all embedded quotes in any `logic` value up to the next key ---
+#     def _esc(m):
+#         prefix, body = m.group(1), m.group(2)
+#         return prefix + body.replace('"', r'\"')
+#     json_string = re.sub(
+#         r'("logic"\s*:\s*")([\s\S]+?)(?=",\s*"[A-Za-z_]\w*"\s*:\s*)',
+#         _esc,
+#         json_string
+#     )
+#     logger.debug("Escaped embedded quotes in logic fields.")
+
+#     logger.debug("Quoted unquoted keys.")
+
+#     # --- 6) Remove trailing commas before } or ] ---
+#     json_string = re.sub(r',\s*(?=[}\],])', '', json_string)
+#     json_string = re.sub(r',\s*,', ',', json_string)
+#     logger.debug("Removed trailing commas.")
+
+#     # --- 7) Balance braces: drop extra } at end if needed ---
+#     ob, cb = json_string.count('{'), json_string.count('}')
+#     if cb > ob:
+#         excess = cb - ob
+#         json_string = json_string.rstrip()[:-excess]
+#         logger.debug(f"Stripped {excess} extra closing brace(s).")
+
+#     # --- 8) Escape literal newlines in *all* string values ---
+#     json_string = re.sub(
+#         r'"((?:[^"\\]|\\.)*?)"',
+#         lambda m: '"' + m.group(1).replace('\n', '\\n').replace('\r', '\\r') + '"',
+#         json_string,
+#         flags=re.DOTALL
+#     )
+#     logger.debug("Escaped newlines in strings.")
+
+#     # --- 9) Final parse attempt ---
+#     try:
+#         return json.loads(json_string)
+#     except json.JSONDecodeError:
+#         logger.error("Sanitized JSON still invalid:\n%s", json_string)
+#         raise
 
-    Accepts:
-      - a list of base64 strings → picks the first element
-      - a PIL Image instance       → encodes to PNG/base64
-      - a raw base64 string        → strips whitespace and data URI prefix
-    """
-    if not raw_b64:
-        return ""
-
-    # 1. If it’s a list, take its first element
-    if isinstance(raw_b64, list):
-        raw_b64 = raw_b64[0] if raw_b64 else ""
-        if not raw_b64:
-            return ""
-
-    # 2. If it’s a PIL Image, convert to base64
-    if isinstance(raw_b64, Image.Image):
-        buf = io.BytesIO()
-        raw_b64.save(buf, format="PNG")
-        raw_b64 = base64.b64encode(buf.getvalue()).decode()
-
-    # 3. At this point it must be a string
-    if not isinstance(raw_b64, str):
-        raise TypeError(f"Expected base64 string or PIL Image, got {type(raw_b64)}")
-
-    # 4. Strip any existing data URI prefix, whitespace, or newlines
-    clean_b64 = re.sub(r"^data:image\/[a-zA-Z]+;base64,", "", raw_b64)
-    clean_b64 = clean_b64.replace("\n", "").replace("\r", "").strip()
-
-    # 5. Validate it’s proper base64
-    try:
-        base64.b64decode(clean_b64)
-    except Exception as e:
-        logger.error(f"Invalid Base64 passed to model: {e}")
-        raise
+# def clean_base64_for_model(raw_b64):
+#     """
+#     Normalize input into a valid data:image/png;base64,<payload> string.
 
-    # 6. Return with the correct data URI prefix
-    return f"data:image/png;base64,{clean_b64}"
+#     Accepts:
+#       - a list of base64 strings → picks the first element
+#       - a PIL Image instance       → encodes to PNG/base64
+#       - a raw base64 string        → strips whitespace and data URI prefix
+#     """
+#     if not raw_b64:
+#         return ""
+
+#     # 1. If it’s a list, take its first element
+#     if isinstance(raw_b64, list):
+#         raw_b64 = raw_b64[0] if raw_b64 else ""
+#         if not raw_b64:
+#             return ""
+
+#     # 2. If it’s a PIL Image, convert to base64
+#     if isinstance(raw_b64, Image.Image):
+#         buf = io.BytesIO()
+#         raw_b64.save(buf, format="PNG")
+#         raw_b64 = base64.b64encode(buf.getvalue()).decode()
+
+#     # 3. At this point it must be a string
+#     if not isinstance(raw_b64, str):
+#         raise TypeError(f"Expected base64 string or PIL Image, got {type(raw_b64)}")
+
+#     # 4. Strip any existing data URI prefix, whitespace, or newlines
+#     clean_b64 = re.sub(r"^data:image\/[a-zA-Z]+;base64,", "", raw_b64)
+#     clean_b64 = clean_b64.replace("\n", "").replace("\r", "").strip()
+
+#     # 5. Validate it’s proper base64
+#     try:
+#         base64.b64decode(clean_b64)
+#     except Exception as e:
+#         logger.error(f"Invalid Base64 passed to model: {e}")
+#         raise
 
+#     # 6. Return with the correct data URI prefix
+#     return f"data:image/png;base64,{clean_b64}"
 
 
 # # Node 1: Logic updating if any issue here
@@ -1707,220 +1706,220 @@ def clean_base64_for_model(raw_b64):
 #                 ]
 
 # Node 6: Logic updating if any issue here
-def plan_logic_aligner_node(state: GameState):
-    logger.info("--- Running plan_logic_aligner_node ---")
+# def plan_logic_aligner_node(state: GameState):
+#     logger.info("--- Running plan_logic_aligner_node ---")
 
-    image = state.get("image", "")
+#     image = state.get("image", "")
     
-    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.
-        --- Scratch 3.0 Block Reference ---
-            ### Hat Blocks
-            Description: {hat_description}
-            Blocks:
-            {hat_opcodes_functionalities}
+#     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.
+#         --- Scratch 3.0 Block Reference ---
+#             ### Hat Blocks
+#             Description: {hat_description}
+#             Blocks:
+#             {hat_opcodes_functionalities}
         
-            ### Boolean Blocks
-            Description: {boolean_description}
-            Blocks:
-            {boolean_opcodes_functionalities}
+#             ### Boolean Blocks
+#             Description: {boolean_description}
+#             Blocks:
+#             {boolean_opcodes_functionalities}
         
-            ### C Blocks
-            Description: {c_description}
-            Blocks:
-            {c_opcodes_functionalities}
+#             ### C Blocks
+#             Description: {c_description}
+#             Blocks:
+#             {c_opcodes_functionalities}
         
-            ### Cap Blocks
-            Description: {cap_description}
-            Blocks:
-            {cap_opcodes_functionalities}
+#             ### Cap Blocks
+#             Description: {cap_description}
+#             Blocks:
+#             {cap_opcodes_functionalities}
         
-            ### Reporter Blocks
-            Description: {reporter_description}
-            Blocks:
-            {reporter_opcodes_functionalities}
+#             ### Reporter Blocks
+#             Description: {reporter_description}
+#             Blocks:
+#             {reporter_opcodes_functionalities}
         
-            ### Stack Blocks
-            Description: {stack_description}
-            Blocks:
-            {stack_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" find...
-        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.
+#         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" find...
+#         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.
+#         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.
         
-        3. **Pseudo‑code formatting**:
-        - Represent each block or nested block on its own line.
-        - Indent nested blocks by 4 spaces under their parent (`forever`, `if`, etc.).
-        - 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.
+#         3. **Pseudo‑code formatting**:
+#         - Represent each block or nested block on its own line.
+#         - Indent nested blocks by 4 spaces under their parent (`forever`, `if`, etc.).
+#         - 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.
         
-        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.
+#         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
-        ```
-        **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": {
-            "url": f"data:image/png;base64,{image}"
-        }
-    }
+#         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
+#         ```
+#         **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": {
+#             "url": f"data:image/png;base64,{image}"
+#         }
+#     }
 
-    content = [
-        {"type": "text", "text": refinement_prompt},
-        image_input
-    ]
+#     content = [
+#         {"type": "text", "text": refinement_prompt},
+#         image_input
+#     ]
 
-    try:
-        # Invoke the main agent for logic refinement and relationship identification
-        response = agent.invoke({"messages": [{"role": "user", "content": content}]})
-        llm_output_raw = response["messages"][-1].content.strip()
+#     try:
+#         # Invoke the main agent for logic refinement and relationship identification
+#         response = agent.invoke({"messages": [{"role": "user", "content": content}]})
+#         llm_output_raw = response["messages"][-1].content.strip()
 
-        parsed_llm_output = extract_json_from_llm_response(llm_output_raw)
+#         parsed_llm_output = extract_json_from_llm_response(llm_output_raw)
         
-        # result = parsed_llm_output
-        # Extract needed values directly
-        logic_data = parsed_llm_output.get("refined_logic", {})
-        name_variable = logic_data.get("name_variable", "Unknown")
-        pseudocode = logic_data.get("pseudocode", "No logic extracted")
+#         # result = parsed_llm_output
+#         # Extract needed values directly
+#         logic_data = parsed_llm_output.get("refined_logic", {})
+#         name_variable = logic_data.get("name_variable", "Unknown")
+#         pseudocode = logic_data.get("pseudocode", "No logic extracted")
         
-        result = {"pseudo_node": {
-            "name_variable": name_variable,
-            "pseudocode": pseudocode
-        }}
+#         result = {"pseudo_node": {
+#             "name_variable": name_variable,
+#             "pseudocode": pseudocode
+#         }}
         
-        print(f"result:\n\n {result}")
-        return result
-    except Exception as e:
-        logger.error(f"❌ plan_logic_aligner_node failed: {str(e)}")
-        return {"error": str(e)}
-    except json.JSONDecodeError as error_json:
-        # If JSON parsing fails, use the json resolver agent
-        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 `refined_logic` (string) and `block_relationships` (array of objects).\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_raw}\n```\n"
-            "Corrected JSON:\n"
-        )
-        try:
-            correction_response = agent_json_resolver.invoke({"messages": [{"role": "user", "content": correction_prompt}]})
-            corrected_output = extract_json_from_llm_response(correction_response["messages"][-1].content)
+#         print(f"result:\n\n {result}")
+#         return result
+#     except Exception as e:
+#         logger.error(f"❌ plan_logic_aligner_node failed: {str(e)}")
+#         return {"error": str(e)}
+#     except json.JSONDecodeError as error_json:
+#         # If JSON parsing fails, use the json resolver agent
+#         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 `refined_logic` (string) and `block_relationships` (array of objects).\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_raw}\n```\n"
+#             "Corrected JSON:\n"
+#         )
+#         try:
+#             correction_response = agent_json_resolver.invoke({"messages": [{"role": "user", "content": correction_prompt}]})
+#             corrected_output = extract_json_from_llm_response(correction_response["messages"][-1].content)
             
-            result = {
-                #"image_path": image_path,
-                "pseudo_code": corrected_output
-            }
+#             result = {
+#                 #"image_path": image_path,
+#                 "pseudo_code": corrected_output
+#             }
             
-            return result
+#             return result
         
-        except Exception as e_corr:
-            logger.error(f"Failed to correct JSON output for even after retry: {e_corr}")
+#         except Exception as e_corr:
+#             logger.error(f"Failed to correct JSON output for even after retry: {e_corr}")
 
 #def extract_images_from_pdf(pdf_path: Path, json_base_dir: Path, image_base_dir: Path):
 #def extract_images_from_pdf(pdf_path: Path, json_base_dir: Path):