Update app.py

app.py

@@ -1334,51 +1334,91 @@ If you find any "Code-Blocks" then,
     return state
 
 # Node2: Node Optimizer node
-def node_optimizer(state: GameState):
+
+from typing import Dict, Any
+
+def node_optimizer(state: Dict[str, Any]) -> Dict[str, Any]:
     logger.info("--- Running Node Optimizer Node ---")
-    project_json = state["project_json"]
-    raw = state.get("pseudo_code", {})
-    refined_logic_data = raw.get("refined_logic", {})
+    # safe fetches
+    project_json = state.get("project_json", {}) if isinstance(state.get("project_json", {}), dict) else {}
+    # ensure pseudo_code exists so we can write into it safely
+    raw = state.setdefault("pseudo_code", {})
+    refined_logic_data = raw.get("refined_logic", {}) or {}
+
+    # keep scalar sprite_name (if present) and build a separate map
     sprite_name = refined_logic_data.get("name_variable", "<unknown>")
-    pseudo      = refined_logic_data.get("pseudocode", "")
-    sprite_name = {}
-    project_json_targets = state.get("project_json", {}).get("targets", [])
+    sprite_name_map: Dict[str, str] = {}
+
+    project_json_targets = project_json.get("targets", []) if isinstance(project_json, dict) else []
     for target in project_json_targets:
-        sprite_name[target["name"]] = target["name"]
-    action_flow = state.get("action_plan", {}) 
-    
+        if isinstance(target, dict):
+            name = target.get("name")
+            if name:
+                sprite_name_map[name] = name
+
     try:
-        refined_logic_data["pseudocode"] = separate_scripts(str(pseudo))
-        # Step 4: If you want to update the `state` dictionary with the new refined_logic_data
+        # ensure we read the pseudocode from the same key consistently
+        pseudo_text = refined_logic_data.get("pseudocode", "")
+        refined_logic_data["pseudocode"] = separate_scripts(str(pseudo_text))
+
+        # write refined logic back into state safely
         state["pseudo_code"]["refined_logic"] = refined_logic_data
-        print(f"[The pseudo_code generated here]: { state['pseudo_code']}")
+        logger.debug("[The pseudo_code generated here]: %s", state["pseudo_code"])
+
+        # transform to action flow (expecting transform_logic_to_action_flow to accept the pseudo_code dict)
         state["action_plan"] = transform_logic_to_action_flow(state["pseudo_code"])
-        print(f"[The action plan generated here]: { state['action_plan']}")
- 
-        action_flow = state.get("action_plan", {})     
-        if action_flow.get("action_overall_flow", {}) == {}:
-            plan_data = action_flow.items()
+        logger.debug("[The action plan generated here]: %s", state["action_plan"])
+
+        action_flow = state.get("action_plan", {})
+
+        # Normalize plan_data into a list of (sprite, sprite_data) pairs
+        plan_data = []
+        if isinstance(action_flow, dict):
+            ao = action_flow.get("action_overall_flow")
+            if isinstance(ao, dict) and ao:
+                plan_data = list(ao.items())
+            else:
+                # fall back to the top-level dict items
+                plan_data = list(action_flow.items())
+        elif isinstance(action_flow, list):
+            # possible structure: list of dicts each holding sprite info
+            for item in action_flow:
+                if isinstance(item, tuple) and len(item) == 2:
+                    plan_data.append(item)
+                elif isinstance(item, dict):
+                    # try to detect common shapes
+                    if "name" in item and "plans" in item:
+                        plan_data.append((item["name"], item))
         else:
-            plan_data = action_flow.get("action_overall_flow", {}).items()
-            
+            plan_data = []
+
         refined_flow: Dict[str, Any] = {}
         for sprite, sprite_data in plan_data:
+            if sprite is None:
+                continue
+            sprite_data = sprite_data or {}
             refined_plans = []
             for plan in sprite_data.get("plans", []):
                 logic = plan.get("logic", "")
-                plan["opcode_counts"]= analyze_opcode_counts(str(logic))
+                # analyze_opcode_counts should accept a string
+                plan["opcode_counts"] = analyze_opcode_counts(str(logic))
                 refined_plans.append(plan)
-            refined_flow[sprite] = {
+
+            refined_flow[str(sprite)] = {
                 "description": sprite_data.get("description", ""),
                 "plans": refined_plans
             }
+
         if refined_flow:
-            state["action_plan"] = refined_flow  
+            state["action_plan"] = refined_flow
             logger.info("Node Optimization completed.")
-        
+
+        return state
+
+    except Exception:
+        # log full stacktrace for debugging but return state so caller won't break
+        logger.exception("Error in Node Optimizer Node — returning current state for inspection")
         return state
-    except Exception as e:
-        logger.error(f"Error in Node Optimizer Node: {e}")
 
 # Node 2: planner node
 # def overall_planner_node(state: GameState):