Update app.py

app.py

@@ -22,7 +22,7 @@ from langchain_core.utils.utils import secret_from_env
 from io import BytesIO
 from pathlib import Path
 import os
-from utils.block_relation_builder import block_builder, variable_adder_main
+from utils.block_relation_builder import block_builder#, variable_adder_main
 from langchain.chat_models import ChatOpenAI
 from langchain_openai import ChatOpenAI
 from pydantic import Field, SecretStr
@@ -341,6 +341,174 @@ def find_block_in_all(opcode: str, all_catalogs: list[dict]) -> dict | None:
             return blk
     return None
 
+def variable_intialization(project_data):
+    """
+    Updates variable and broadcast definitions in a Scratch project JSON,
+    populating the 'variables' and 'broadcasts' sections of the Stage target
+    and extracting initial values for variables.
+
+    Args:
+        project_data (dict): The loaded JSON data of the Scratch project.
+
+    Returns:
+        dict: The updated project JSON data.
+    """
+
+    stage_target = None
+    for target in project_data['targets']:
+        if target.get('isStage'):
+            stage_target = target
+            break
+
+    if stage_target is None:
+        print("Error: Stage target not found in the project data.")
+        return project_data
+
+    # Ensure 'variables' and 'broadcasts' exist in the Stage target
+    if "variables" not in stage_target:
+        stage_target["variables"] = {}
+    if "broadcasts" not in stage_target:
+        stage_target["broadcasts"] = {}
+
+    # Helper function to recursively find and update variable/broadcast fields
+    def process_dict(obj):
+        if isinstance(obj, dict):
+            # Check for "data_setvariableto" opcode to extract initial values
+            if obj.get("opcode") == "data_setvariableto":
+                variable_field = obj.get("fields", {}).get("VARIABLE")
+                value_input = obj.get("inputs", {}).get("VALUE")
+
+                if variable_field and isinstance(variable_field, list) and len(variable_field) == 2:
+                    var_name = variable_field[0]
+                    var_id = variable_field[1]
+
+                    initial_value = ""
+                    if value_input and isinstance(value_input, list) and len(value_input) > 1 and \
+                       isinstance(value_input[1], list) and len(value_input[1]) > 1:
+                        if value_input[1][0] == 10:
+                            initial_value = str(value_input[1][1])
+                        elif value_input[1][0] == 12 and len(value_input) > 2 and isinstance(value_input[2], list) and value_input[2][0] == 10:
+                            initial_value = str(value_input[2][1])
+                        elif isinstance(value_input[1], (str, int, float)):
+                            initial_value = str(value_input[1])
+                    stage_target["variables"][var_id] = [var_name, initial_value]
+
+            for key, value in obj.items():
+                # Process broadcast definitions in 'inputs' (BROADCAST_INPUT)
+                if key == "BROADCAST_INPUT" and isinstance(value, list) and len(value) == 2 and \
+                   isinstance(value[1], list) and len(value[1]) == 3 and value[1][0] == 11:
+                    broadcast_name = value[1][1]
+                    broadcast_id = value[1][2]
+                    stage_target["broadcasts"][broadcast_id] = broadcast_name
+
+                # Process broadcast definitions in 'fields' (BROADCAST_OPTION)
+                elif key == "BROADCAST_OPTION" and isinstance(value, list) and len(value) == 2:
+                    broadcast_name = value[0]
+                    broadcast_id = value[1]
+                    stage_target["broadcasts"][broadcast_id] = broadcast_name
+                
+                # Recursively call for nested dictionaries or lists
+                process_dict(value)
+
+        elif isinstance(obj, list):
+            for i, item in enumerate(obj):
+                # Process variable references in 'inputs' (like [12, "score", "id"])
+                if isinstance(item, list) and len(item) == 3 and item[0] == 12:
+                    var_name = item[1]
+                    var_id = item[2]
+                    if var_id not in stage_target["variables"]:
+                        stage_target["variables"][var_id] = [var_name, ""]
+                process_dict(item)
+
+    # Iterate through all targets to process their blocks
+    for target in project_data['targets']:
+        if "blocks" in target:
+            for block_id, block_data in target["blocks"].items():
+                process_dict(block_data)
+
+    return project_data
+
+def deduplicate_variables(project_data):
+    """
+    Removes duplicate variable entries in the 'variables' dictionary of the Stage target,
+    prioritizing entries with non-empty values.
+
+    Args:
+        project_data (dict): The loaded JSON data of the Scratch project.
+
+    Returns:
+        dict: The updated project JSON data with deduplicated variables.
+    """
+
+    stage_target = None
+    for target in project_data['targets']:
+        if target.get('isStage'):
+            stage_target = target
+            break
+
+    if stage_target is None:
+        print("Error: Stage target not found in the project data.")
+        return project_data
+
+    if "variables" not in stage_target:
+        return project_data # No variables to deduplicate
+
+    # Use a temporary dictionary to store the preferred variable entry by name
+    # Format: {variable_name: [variable_id, variable_name, variable_value]}
+    resolved_variables = {}
+
+    for var_id, var_info in stage_target["variables"].items():
+        var_name = var_info[0]
+        var_value = var_info[1]
+
+        if var_name not in resolved_variables:
+            # If the variable name is not yet seen, add it
+            resolved_variables[var_name] = [var_id, var_name, var_value]
+        else:
+            # If the variable name is already seen, decide which one to keep
+            existing_id, existing_name, existing_value = resolved_variables[var_name]
+
+            # Prioritize the entry with a non-empty value
+            if var_value != "" and existing_value == "":
+                resolved_variables[var_name] = [var_id, var_name, var_value]
+            # If both have non-empty values, or both are empty, keep the current one (arbitrary choice, but consistent)
+            # The current logic will effectively keep the last one encountered that has a value,
+            # or the very last one if all are empty.
+            elif var_value != "" and existing_value != "":
+                 # If there are multiple non-empty values for the same variable name
+                 # this keeps the one from the most recent iteration.
+                 # For the given example, this will correctly keep "5".
+                resolved_variables[var_name] = [var_id, var_name, var_value]
+            elif var_value == "" and existing_value == "":
+                # If both are empty, just keep the current one (arbitrary)
+                resolved_variables[var_name] = [var_id, var_name, var_value]
+
+
+    # Reconstruct the 'variables' dictionary using the resolved entries
+    new_variables_dict = {}
+    for var_name, var_data in resolved_variables.items():
+        var_id_to_keep = var_data[0]
+        var_name_to_keep = var_data[1]
+        var_value_to_keep = var_data[2]
+        new_variables_dict[var_id_to_keep] = [var_name_to_keep, var_value_to_keep]
+
+    stage_target["variables"] = new_variables_dict
+
+    return project_data
+
+def variable_adder_main(project_data):
+    try:
+        declare_variable_json=  variable_intialization(project_data)
+        print("declare_variable_json------->",declare_variable_json)
+    except Exception as e:
+        print(f"Error error in the variable initialization opcodes: {e}")
+    try:
+        processed_json= deduplicate_variables(declare_variable_json)
+        print("processed_json------->",processed_json)
+        return processed_json
+    except Exception as e:
+        print(f"Error error in the variable initialization opcodes: {e}")
+
 
 # --- Global variable for the block catalog ---
 ALL_SCRATCH_BLOCKS_CATALOG = {}
@@ -779,7 +947,7 @@ If you find any "Code-Blocks" then,
     print(f"[OVREALL REFINED PSEUDO CODE LOGIC]: {result}")
     logger.info("Plan refinement and block relation analysis completed for all plans.")
     return state
-
+# Node 2: planner node
 def overall_planner_node(state: GameState):
     """
     Generates a comprehensive action plan for sprites, including detailed Scratch block information.
@@ -1087,7 +1255,7 @@ Each plan must include a **single Scratch Hat Block** (e.g., 'event_whenflagclic
     except Exception as e:
         logger.error(f"Error in OverallPlannerNode: {e}")
         raise
-
+# Node 3: refiner node
 def refined_planner_node(state: GameState):
     """
     Refines the action plan based on validation feedback and game description.
@@ -1179,7 +1347,7 @@ Use sprite names exactly as provided in `sprite_names` (e.g., 'Sprite1', 'soccer
      - `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 .
+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]:
     ```
@@ -1396,7 +1564,7 @@ Use sprite names exactly as provided in `sprite_names` (e.g., 'Sprite1', 'soccer
     except Exception as e:
         logger.error(f"Error in RefinedPlannerNode: {e}")
         raise
-
+# Node 4: opcode counter node
 def plan_opcode_counter_node(state: Dict[str, Any]) -> Dict[str, Any]:
     """
     For each plan in state["action_plan"], calls the LLM agent
@@ -1493,13 +1661,14 @@ 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. Return a top-level JSON object with a single key: "opcode_counts".
-3. The value of "opcode_counts" should be a list of objects, where each object has "opcode": "<opcode_name>" and "count": <integer>.
-4. Ensure the list includes the hat block for this plan (e.g., event_whenflagclicked, event_whenkeypressed, event_whenbroadcastreceived) with a count of 1.
-5. The order of opcodes within the "opcode_counts" list does not matter.
-6. If any plan logic is None do not generate the opcode_counts for it.
-7. Use only double quotes and ensure valid JSON.
+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**
@@ -1589,91 +1758,10 @@ Example output:
     logger.info("=== OPCODE COUTER LOGIC completed ===")
     return state
 
-# Node 10:Function based block builder node
-def overall_block_builder_node_2(state: dict):
-    logger.info("--- Running OverallBlockBuilderNode ---")
-
-    project_json = state["project_json"]
-    targets = project_json["targets"]
-    # --- Sprite and Stage Target Mapping ---
-    sprite_map = {target["name"]: target for target in targets if not target["isStage"]}
-    stage_target = next((target for target in targets if target["isStage"]), None)
-    if stage_target:
-        sprite_map[stage_target["name"]] = stage_target
-
-    action_plan = state.get("action_plan", {})
-    print("[Overall Action Plan received at the block generator]:", json.dumps(action_plan, indent=2))
-    if not action_plan:
-        logger.warning("No action plan found in state. Skipping OverallBlockBuilderNode.")
-        return state
-
-    # Initialize offsets for script placement on the Scratch canvas
-    script_y_offset = {}
-    script_x_offset_per_sprite = {name: 0 for name in sprite_map.keys()}
-
-    # This handles potential variations in the action_plan structure.
-    if action_plan.get("action_overall_flow", {}) == {}:
-        plan_data = action_plan.items()
-    else:
-        plan_data = action_plan.get("action_overall_flow", {}).items()
-
-    # --- Extract global project context for LLM ---
-    all_sprite_names = list(sprite_map.keys())
-    all_variable_names = {}
-    all_list_names = {}
-    all_broadcast_messages = {}
-
-    for target in targets:
-        for var_id, var_info in target.get("variables", {}).items():
-            all_variable_names[var_info[0]] = var_id  # Store name -> ID mapping (e.g., "myVariable": "myVarId123")
-        for list_id, list_info in target.get("lists", {}).items():
-            all_list_names[list_info[0]] = list_id  # Store name -> ID mapping
-        for broadcast_id, broadcast_name in target.get("broadcasts", {}).items():
-            all_broadcast_messages[broadcast_name] = broadcast_id  # Store name -> ID mapping
-
-    # --- Process each sprite's action plan ---
-    for sprite_name, sprite_actions_data in plan_data:
-        if sprite_name in sprite_map:
-            current_sprite_target = sprite_map[sprite_name]
-            if "blocks" not in current_sprite_target:
-                current_sprite_target["blocks"] = {}
-
-            if sprite_name not in script_y_offset:
-                script_y_offset[sprite_name] = 0
-
-            for plan_entry in sprite_actions_data.get("plans", []):
-                logic_sequence = str(plan_entry["logic"])
-                opcode_counts = plan_entry.get("opcode_counts", {})
-
-                try:
-                    generated_blocks=block_builder(opcode_counts,logic_sequence)                
-                    if "blocks" in generated_blocks and isinstance(generated_blocks["blocks"], dict):
-                        logger.warning(f"LLM returned nested 'blocks' key for {sprite_name}. Unwrapping.")
-                        generated_blocks = generated_blocks["blocks"]
-
-                    # Update block positions for top-level script
-                    for block_id, block_data in generated_blocks.items():
-                        if block_data.get("topLevel"):
-                            block_data["x"] = script_x_offset_per_sprite.get(sprite_name, 0)
-                            block_data["y"] = script_y_offset[sprite_name]
-                            script_y_offset[sprite_name] += 150 # Increment for next script
-
-                    current_sprite_target["blocks"].update(generated_blocks)
-                    print(f"[current_sprite_target block updated]: {current_sprite_target['blocks']}")
-                    state["iteration_count"] = 0
-                    logger.info(f"Action blocks added for sprite '{sprite_name}' by OverallBlockBuilderNode.")
-                except Exception as e:
-                    logger.error(f"Error generating blocks for sprite '{sprite_name}': {e}")
-                    
-    state["project_json"] = project_json
-    # with open("debug_state.json", "w", encoding="utf-8") as f:
-    #     json.dump(state, f, indent=2, ensure_ascii=False)
-    
-    return state
-# Node 10:Function based block builder node
-def overall_block_builder_node_2(state: dict):
+# Node 5: block_builder_node
+def overall_block_builder_node_2(state: GameState):
     logger.info("--- Running OverallBlockBuilderNode ---")
-
+    print("--- Running OverallBlockBuilderNode ---")
     project_json = state["project_json"]
     targets = project_json["targets"]
     # --- Sprite and Stage Target Mapping ---
@@ -1762,12 +1850,17 @@ def overall_block_builder_node_2(state: dict):
     
     return state
 
-# # Node 11: Variable adder node
+# Node 6: variable adder node
 def variable_adder_node(state: GameState):
     project_json = state["project_json"]
     try:
         updated_project_json = variable_adder_main(project_json)
-        state["project_json"]=updated_project_json
+        if updated_project_json is not None:
+            print("Variable added inside the project successfully!")
+            state["project_json"]=updated_project_json
+        else:
+            print("Variable adder unable to add any variable inside the project!")
+            state["project_json"]=project_json
         return state
     except Exception as e:
         logger.error(f"Error in variable adder node while updating project_json': {e}")