Update utils/block_relation_builder.py

utils/block_relation_builder.py

@@ -1,7 +1,7 @@
 import json
 import copy
 import re
-from collections import defaultdict
+from collections import defaultdict, Counter
 import secrets
 import string
 from typing import Dict, Any, TypedDict,Tuple
@@ -1797,7 +1797,8 @@ def classify(line):
     if l.startswith("//"): return None, None
 
     # Hat Blocks (most specific first)
-    if re.match(r"when green flag click(ed)?", l): return "event_whenflagclicked", "hat"
+    # if re.match(r"when green flag click(ed)?", l): return "event_whenflagclicked", "hat"
+    if re.fullmatch(r"when (green )?flag click(ed)?", l.strip(), re.IGNORECASE): return "event_whenflagclicked", "hat"
     if re.match(r"when (.+?) key press(ed)?", l): return "event_whenkeypressed", "hat"
     if re.match(r"when this sprite click(ed)?", l): return "event_whenthisspriteclicked", "hat"
     if l.startswith("when backdrop switches to"): return "event_whenbackdropswitchesto", "hat"
@@ -2353,34 +2354,34 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
                 info["fields"]["VARIABLE"] = [var_name, None]
         if "LIST" in info["fields"]:
             m = re.search(r"(?:to|of|in)\s*\[([^\]]+)\s*v\]", stmt_for_parse)
-            if m: info["fields"]["LIST"] = [m.group(1), None]
+            if m: info["fields"]["LIST"] = [m.group(1).strip(), None]
         if "STOP_OPTION" in info["fields"]:
             m = re.search(r"stop \[([^\]]+)\s*v\]", stmt_for_parse)
             if m: info["fields"]["STOP_OPTION"] = [m.group(1).strip(), None]
         if "STYLE" in info["fields"]:
             m = re.search(r"set rotation style \[([^\]]+)\s*v\]", stmt_for_parse)
-            if m: info["fields"]["STYLE"] = [m.group(1), None]
+            if m: info["fields"]["STYLE"] = [m.group(1).strip(), None]
         if "DRAG_MODE" in info["fields"]:
             m = re.search(r"set drag mode \[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
-            if m: info["fields"]["DRAG_MODE"] = [m.group(1), None]
+            if m: info["fields"]["DRAG_MODE"] = [m.group(1).strip(), None]
         if "EFFECT" in info["fields"] and opcode in ["looks_changeeffectby", "looks_seteffectto", "sound_changeeffectby", "sound_seteffectto"]:
             m = re.search(r"(?:change|set)\s*\[([^\]]+)\s*v\] effect", stmt_for_parse, re.IGNORECASE)
-            if m: info["fields"]["EFFECT"] = [m.group(1).upper(), None]
+            if m: info["fields"]["EFFECT"] = [m.group(1).upper().strip(), None]
         if "NUMBER_NAME" in info["fields"] and opcode in ["looks_costumenumbername", "looks_backdropnumbername"]:
             m = re.search(r"(?:costume|backdrop)\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
-            if m: info["fields"]["NUMBER_NAME"] = [m.group(1), None]
+            if m: info["fields"]["NUMBER_NAME"] = [m.group(1).strip(), None]
         if "FRONT_BACK" in info["fields"] and opcode == "looks_gotofrontback":
             m = re.search(r"go to\s*\[([^\]]+)\s*v\] layer", stmt_for_parse, re.IGNORECASE)
-            if m: info["fields"]["FRONT_BACK"] = [m.group(1), None]
+            if m: info["fields"]["FRONT_BACK"] = [m.group(1).strip(), None]
         if "FORWARD_BACKWARD" in info["fields"] and opcode == "looks_goforwardbackwardlayers":
             m = re.search(r"go\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
-            if m: info["fields"]["FORWARD_BACKWARD"] = [m.group(1), None]
+            if m: info["fields"]["FORWARD_BACKWARD"] = [m.group(1).strip(), None]
         if "OPERATOR" in info["fields"] and opcode == "operator_mathop":
             m = re.search(r"\[([^\]]+)\s*v\] of", stmt_for_parse, re.IGNORECASE)
-            if m: info["fields"]["OPERATOR"] = [m.group(1).upper(), None]
+            if m: info["fields"]["OPERATOR"] = [m.group(1).upper().strip(), None]
         if "CURRENTMENU" in info["fields"] and opcode == "sensing_current":
             m = re.search(r"current\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
-            if m: info["fields"]["CURRENTMENU"] = [m.group(1).upper(), None]
+            if m: info["fields"]["CURRENTMENU"] = [m.group(1).upper().strip(), None]
         if "PROPERTY" in info["fields"] and opcode == "sensing_of":
             m = re.search(r"\((.+?)\) of", stmt_for_parse, re.IGNORECASE)
             if m:
@@ -2393,16 +2394,16 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
                 info["fields"]["PROPERTY"] = [prop_map.get(prop, prop), None]
         if "WHENGREATERTHANMENU" in info["fields"] and opcode == "event_whengreaterthan":
             m = re.search(r"when\s*\[([^\]]+)\s*v\] >", stmt_for_parse, re.IGNORECASE)
-            if m: info["fields"]["WHENGREATERTHANMENU"] = [m.group(1).upper(), None]
+            if m: info["fields"]["WHENGREATERTHANMENU"] = [m.group(1).upper().strip(), None]
         if "KEY_OPTION" in info["fields"] and opcode == "event_whenkeypressed": # For event_whenkeypressed hat block's field
             m = re.search(r"when\s*\[([^\]]+)\s*v\] key pressed", stmt_for_parse, re.IGNORECASE)
-            if m: info["fields"]["KEY_OPTION"] = [m.group(1), None]
+            if m: info["fields"]["KEY_OPTION"] = [m.group(1).strip(), None]
         if "BACKDROP" in info["fields"] and opcode == "event_whenbackdropswitchesto": # For event_whenbackdropswitchesto hat block's field
             m = re.search(r"when backdrop switches to\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
-            if m: info["fields"]["BACKDROP"] = [m.group(1), None]
+            if m: info["fields"]["BACKDROP"] = [m.group(1).strip(), None]
         if "BROADCAST_OPTION" in info["fields"] and opcode == "event_whenbroadcastreceived": # For event_whenbroadcastreceived hat block's field
             m = re.search(r"when i receive\s*\[([^\]]+)\s*v\]", stmt_for_parse, re.IGNORECASE)
-            if m: info["fields"]["BROADCAST_OPTION"] = [m.group(1), None]
+            if m: info["fields"]["BROADCAST_OPTION"] = [m.group(1).strip(), None]
 
         # Custom block specific parsing
         if opcode == "procedures_definition":
@@ -2458,7 +2459,6 @@ def generate_plan(generated_input, opcode_keys, pseudo_code):
                         info["mutation"]["argumentnames"].append(f"arg{idx+1}") # Placeholder name for mutation
                         
                         info["inputs"][arg_input_name] = parse_reporter_or_value(arg_val_str, key, pick_key, all_generated_blocks) # Pass current block's key
-
         i += 1 # Move to the next line
 
     # Final pass to ensure last blocks have next: None (already handled by stack pops)
@@ -2513,8 +2513,8 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
 
     # Initialize dictionaries to store and reuse generated unique IDs
     # This prevents creating multiple unique IDs for the same variable/broadcast across different blocks
-    variable_id_map = defaultdict(lambda: generate_secure_token(20))
-    broadcast_id_map = defaultdict(lambda: generate_secure_token(20))
+    variable_id_map = defaultdict(lambda: generate_secure_token())
+    broadcast_id_map = defaultdict(lambda: generate_secure_token())
 
     # Define the mapping for input field names to their required integer types for shadows
     input_type_mapping = {
@@ -2603,7 +2603,7 @@ def process_scratch_blocks(all_generated_blocks, generated_output_json):
                     else:
                         # Fallback: try original generated_output_json value if present, else synthesize
                         fallback = gen_block_data.get("inputs", {}).get(input_name,
-                                                                       [1, [11, "message1", generate_secure_token(20)]])
+                                                                       [1, [11, "message1", generate_secure_token()]])
                         processed_block["inputs"][input_name] = fallback
                     continue
 
@@ -3066,6 +3066,275 @@ def variable_adder_main(project_data):
         return processed_json
     except Exception as e:
         print(f"Error error in the variable initialization opcodes: {e}")
+
+#################################################################################################################################################################
+#--------------------------------------------------[Helper function to generate Opcode]--------------------------------------------------------------------------
+#################################################################################################################################################################
+
+def _find_all_opcodes(code_block: str) -> list[str]:
+    """
+    Finds all Scratch opcodes in a given code block using a series of
+    regex patterns. This function is designed to handle multi-line blocks
+    by processing the entire code block and finding all matches. The
+    patterns are ordered from most specific to least specific to prevent
+    misclassification.
+
+    Args:
+        code_block: A string containing the entire pseudo-code.
+
+    Returns:
+        A list of all detected opcode strings.
+    """
+    opcodes = []
+    
+    # Define a list of regex patterns and their corresponding opcodes,
+    # ordered from most specific to least specific. The re.DOTALL flag
+    # allows '.' to match newlines, which is crucial for multi-line blocks.
+    patterns = [
+        # --- Multi-line Control Blocks (most specific, non-greedy) ---
+        (r"if <.+?> then(?:.|\n)+?else(?:.|\n)+?end", "control_if_else"), #(to test muliple stack)
+        (r"forever", "control_forever"),
+        (r"if <.+?> then", "control_if"),
+        (r"repeat until <.+?>", "control_repeat_until"),
+        (r"repeat\s+(?:\(.+?\)|\[.+?(?:\s+v)?\]|\S+)", "control_repeat"),
+        (r"stop\s+(?:all|this script|other scripts in sprite|\[(?:all|this script|other scripts in sprite)(?:\s+v)?\])(?!\s+sounds)", "control_stop"),
+        (r"when I start as a clone", "control_start_as_clone"),
+        (r"create clone of \[.+?(?:\s+v)?\]", "control_create_clone_of"),
+        (r"delete this clone", "control_delete_this_clone"),
+        (r"wait\s+(?:\(.+?\)|\[.+?(?:\s+v)?\]|\S+)\s+sec(?:ond)?s?", "control_wait"),
+        (r"wait until <.+?>", "control_wait_until"),
+
+        # --- Event Blocks (most specific) ---
+        # (r"when green flag clicked", "event_whenflagclicked"),
+        (r"when (green )?flag click(ed)?", "event_whenflagclicked"),
+        (r"when\s+(?:key\s+\[(.+?)(?:\s+v)?\]|\[(.+?)(?:\s+v)?\]\s+key)\s+pressed", "event_whenkeypressed"),
+        (r"when this sprite clicked", "event_whenthisspriteclicked"),
+        (r"when backdrop switches to \[.+?(?:\s+v)?\]", "event_whenbackdropswitchesto"),
+        (r"when I receive \[.+?(?:\s+v)?\]", "event_whenbroadcastreceived"),
+        (r"when \[.+?(?:\s+v)?\] > (.+)", "event_whengreaterthan"),
+        (r"broadcast \[.+?(?:\s+v)?\] and wait", "event_broadcastandwait"),
+        (r"broadcast \[.+?(?:\s+v)?\]", "event_broadcast"),
+
+        # --- Data Blocks (Variables and Lists) - specific block types first ---
+        (r"set\s*\[\s*.+?(?:\s+v)?\s*\]\s*to\s*\(?\s*.+?\s*\)?", "data_setvariableto"),
+        (r"change\s*\[\s*.+?(?:\s+v)?\s*\]\s*by\s*\(?\s*.+?\s*\)?", "data_changevariableby"),
+        (r"show variable \[.+?(?:\s+v)?\]", "data_showvariable"),
+        (r"hide variable \[.+?(?:\s+v)?\]", "data_hidevariable"),
+        (r"show list \[.+?(?:\s+v)?\]", "data_showlist"),
+        (r"hide list \[.+?(?:\s+v)?\]", "data_hidelist"),
+        (r"add\s+(?:\[.+?\]|\(.+?\)|\w+)\s+to\s+\[.+?(?:\s+v)?\]", "data_addtolist"),
+        (r"delete\s*\((?!all\)).+?\)\s*of\s*\[.+?(?:\s+v)?\]", "data_deleteoflist"),
+        (r"delete\s*\(all\)\s*of\s*\[.+?(?:\s+v)?\]", "data_deletealloflist"),
+        (r"insert\s+(\(.+?\)|\[.+?\]|\(\[.+?\]\)|[^\s]+)\s+at\s+(\(.+?\)|\[.+?\]|\(\[.+?\]\)|\d+)\s+of\s+\[.+?(?:\s+v)?\]", "data_insertatlist"),
+        (r"replace\s+item\s+(\(.+?\)|\[\s*.+?\s*(?:v)?\]|[^\s]+)\s+of\s+\[.+?(?:\s+v)?\]\s+with\s+(\(.+?\)|\[\s*.+?\s*(?:v)?\]|.+)","data_replaceitemoflist"),
+        (r"[<(]\s*\[[^\]]+?\s+v\]\s*contains\s*\[[^\]]+?\]\s*\??\s*[)>]", "data_listcontainsitem"),
+        (r"\(item\s+#\s+of\s+\(?(.+?)\)?\s+in\s+\[.+?(?:\s+v)?\]\)", "data_itemnumoflist"),
+        (r"(?<!replace\s)\(?item(?!\s+#)\s+(\(.+?\)|\[\s*.+?\s*(?:v)?\]|[^\s]+)\s+of\s+\[.+?(?:\s+v)?\]\)?", "data_itemoflist"),
+        (r"\(length of \[.+?(?:\s+v)?\]\)", "data_lengthoflist"),
+        
+        # --- Sensing Blocks ---
+        (r"ask \[.+?\] and wait", "sensing_askandwait"),
+        (r"(?<!when\s)key\s+\[.+?(?:\s+v)?\]\s+pressed\??", "sensing_keypressed"),
+        (r"mouse down\??", "sensing_mousedown"),
+        (r"""\s*<?\s*color\s*\[?\s*(#[0-9A-Fa-f]{6})\s*\]?\s*is\s+touching\s*\[?\s*(#[0-9A-Fa-f]{6})\s*\]?\s*\??\s*>?\s*""", "sensing_coloristouchingcolor"),
+        (r"(?<!is\s)touching\s*(?:color\s*)?\[?\s*#([0-9A-Fa-f]{6})\s*\]?\??", "sensing_touchingcolor"),
+        (r"touching \[.+? v\]\??", "sensing_touchingobject"),
+        (r"set drag mode \[.+? v\]", "sensing_setdragmode"),
+        (r"reset timer", "sensing_resettimer"),
+        (r"(?i)(?<!\bat\s)(?<!\bdelete\s)(?<!\binsert\s)(?<!\breplace\s)(?<!\bcreate\s)(?<!\bitem\s)(?<!\bletter\s)"r"(?:"r"\(\s*(?!(?:item\b|\d+|\#|length\b|insert\b|delete\b|replace\b|create\b|letter\b))[^()]{1,200}?\)\s*of\s*\[[^\]]+?(?:\s+v)?\](?!\s*in\s*\[)"r"|"r"\(\s*(?!(?:item\b|\d+|\#|length\b|insert\b|delete\b|replace\b|create\b|letter\b)).*?of\s*\[[^\]]+?(?:\s+v)?\].*?\)"r"|"r"\[\s*(?!(?:item\b|\d+|\#|length\b|letter\b))[^\]]+?\]\s*of\s*\[[^\]]+?(?:\s+v)?\](?!\s*in\s*\[)"r"|"r"\b(?:backdrop|costume|x\s+position|y\s+position|direction|size|volume|loudness|answer|day|month|year|username|timer|mouse\s+x|mouse\s+y)\b\s*of\s*\[[^\]]+?(?:\s+v)?\](?!\s*in\s*\[)"r")","sensing_of"),
+        (r"\(current \[.+? v]\)", "sensing_current"),
+        (r"\(?answer\)?", "sensing_answer"),         #(to test muliple bracket and alone should treet as the keyword)
+        (r"\(?username\)?", "sensing_username"),     #(to test muliple bracket and alone should treet as the keyword)
+        
+        # --- Sound Blocks ---
+        (r"play sound \[.+? v\] until done", "sound_playuntildone"),
+        (r"start sound \[.+? v\]", "sound_play"),
+        (r"stop all sounds", "sound_stopallsounds"),
+        (r"change volume by\s*(?:\((.+?)\)|\[(.+?)\]|(.+))", "sound_changevolumeby"),
+        (r"""set\ volume\ to\s+\(?\s*(?:-?\d+(?:\.\d+)?|\[?[a-zA-Z_][\w\s]*\]?(?:\ v)?)\s*\)?\s*%?""", "sound_setvolumeto"),
+        
+        (r"\(volume\)", "sound_volume"),
+
+        # --- Motion Blocks ---
+        (r"go to x:\s*\(?(.+?)\)?\s*y:\s*\(?(.+?)\)?", "motion_gotoxy"),
+        (r"set x to (.+)", "motion_setx"),
+        (r"set y to (.+)", "motion_sety"),
+        (r"move\s*\(?(.+?)\)?\s*(?:steps?)?", "motion_movesteps"),
+        (r"turn right\s*\(?(.+?)\)?\s*(?:degrees?)?", "motion_turnright"),
+        (r"turn left\s*\(?(.+?)\)?\s*(?:degrees?)?", "motion_turnleft"),
+        (r"go to\s*(?:random position|mouse-pointer|\[.*?\]|.+)", "motion_goto"),   #(to mouse-pointer is not include here for now) 
+        (r"point in direction\s*\(?(.+?)\)?", "motion_pointindirection"),
+        (r"point towards \[.+? v\]", "motion_pointtowards"),
+        (r"change x by\s*\(?(.+?)\)?", "motion_changexby"),
+        (r"change y by\s*\(?(.+?)\)?", "motion_changeyby"),
+        (r"glide\s*\(?(.+?)\)?\s*(?:sec|secs|second|seconds)\s*to\s*x:\s*\(?(.+?)\)?\s*y:\s*\(?(.+?)\)?", "motion_glidesecstoxy"),
+        (r"glide\s*\(?(.+?)\)?\s*(?:sec|secs|second|seconds)\s*to\s*\[.*?\]", "motion_glideto"),
+        (r"if on edge, bounce", "motion_ifonedgebounce"),
+        (r"set rotation style\s*\[(?:left-right|all around|don't rotate)(?:\s*v)?\]", "motion_setrotationstyle"),
+        (r"\(?x position\)?", "motion_xposition"), #(to x positon may detect where var is used) 
+        (r"\(?y position\)?", "motion_yposition"), #(to y position  may detect where var is used) 
+        (r"\(?direction\)?", "motion_direction"),  #(to direction  may detect where var is used) 
+        
+        # --- Looks Blocks ---
+        (r"switch costume to \[.+? v\]", "looks_switchcostumeto"),
+        (r"next costume", "looks_nextcostume"),
+        (r"switch backdrop to \[.+? v\] and wait", "looks_switchbackdroptowait"),
+        (r"switch backdrop to \[.+? v\]", "looks_switchbackdropto"),
+        (r"next backdrop", "looks_nextbackdrop"),
+        (r"^\s*show\s*$", "looks_show"),
+        (r"^\s*hide\s*$", "looks_hide"),
+        (r"say\s+(?:\[.+?\]|\(.+?\)|.+?)\s*for\s*\(?(.+?)\)?\s*(?:sec|secs|second|seconds)", "looks_sayforsecs"),
+        (r"say\s+(?!.*\bfor\b\s*\(?\d+\)?\s*(?:sec|secs|second|seconds))(?:\[.+?\]|\(.+?\)|.+?)", "looks_say"),
+        (r"think\s*\[.+?\]\s*for\s*\(?(.+?)\)?\s*(?:sec|secs|second|seconds)", "looks_thinkforsecs"),
+        (r"think\s*\[.+?\]", "looks_think"),
+        (r"change size by\s*\(?(.+?)\)?", "looks_changesizeby"),
+        (r"set size to\s*\(?(.+?)\)?\s*%?", "looks_setsizeto"),
+        (r"change\s*\[(.+?)(?:\s*v)?\]\s*effect by\s*\(?(.+?)\)?", "looks_changeeffectby"),
+        (r"set\s*\[(.+?)(?:\s*v)?\]\s*effect to\s*\(?(.+?)\)?", "looks_seteffectto"),
+        (r"clear graphic effects", "looks_cleargraphiceffects"),
+        (r"\(costume \[.+? v\]\)", "looks_costumenumbername"),
+        (r"\(backdrop \[.+? v\]\)", "looks_backdropnumbername"),
+
+        # --- Operators ---
+        (r"<\s*[^<>?]+\s*<\s*[^<>?]+\s*>", "operator_lt"),
+        (r"<\s*[^<>?]+\s*=\s*[^<>?]+\s*>", "operator_equals"),
+        (r"<\s*[^<>?]+\s*>\s*[^<>?]+\s*>", "operator_gt"),
+        (r"<\s*.*?\s+and\s+.*?\s*>", "operator_and"),
+        (r"<\s*.*?\s+or\s+.*?\s*>", "operator_or"),
+        (r"<\s*not\s+.*?\s*>", "operator_not"),
+        (r"(?:\(join\s+(.+?)\s+(.+?)\)|join\s+(.+?)\s+(.+?))", "operator_join"),
+        (r"\(\s*.+?\s*\+\s*.+?\s*\)", "operator_add"),
+        (r"\(\s*(?!-\s*\d+(?:\.\d+)?\s*\))(.+?)\s+-\s+(.+?)\)", "operator_subtract"),
+        (r"\(\s*.+?\s*\*\s*.+?\s*\)", "operator_multiply"),
+        (r"\(\s*.+?\s*/\s*.+?\s*\)", "operator_divide"),
+        (r"\(pick random\s+(.+?)\s+to\s+(.+?)\)", "operator_random"),
+        (r"\(letter\s+(.+?)\s+of\s+(.+?)\)", "operator_letterof"),
+        (r"\(length of\s+(.+?)\)", "operator_length"),
+        (r"\(\s*.+?\s+mod\s+.+?\s*\)", "operator_mod"),
+        (r"\(round\s+(.+?)\)", "operator_round"),
+        (r"[<(]\s*\[(?![^\]]*\s+v\])[^\]]+?\]\s*contains\s*\[[^\]]+?\]\s*\??\s*[)>]", "operator_contains"),
+        (r"\(\s*\[?(abs|floor|ceiling|sqrt|sin|cos|tan|asin|acos|atan|ln|log|e \^|10 \^)\s*(?:v)?\]?\s+of\s+.+?\)", "operator_mathop"),
+
+    ]
+
+    for pattern, opcode in patterns:
+        for match in re.finditer(pattern, code_block, re.DOTALL):
+            opcodes.append(opcode)
+            
+    return opcodes
+
+def analyze_opcode_counts(pseudo_code: str) -> list[dict]:
+    """
+    Analyzes a block of Scratch-like pseudo-code to count the occurrences
+    of each opcode using a multi-pass, regex-based classifier.
+
+    Args:
+        pseudo_code: A string containing the pseudo-code.
+
+    Returns:
+        A list of dictionaries, where each dictionary contains the opcode
+        and its count.
+    """
+    opcode_counts = Counter()
+
+    opcodes_in_code = _find_all_opcodes(pseudo_code)
+    for opcode in opcodes_in_code:
+        opcode_counts[opcode] += 1
+    
+    result = [{"opcode": opcode, "count": count} for opcode, count in opcode_counts.items()]
+    
+    # Sort the result by opcode for consistent output.
+    result.sort(key=lambda x: x['opcode'])
+    
+    return result
+
+#################################################################################################################################################################
+#--------------------------------------------------[Helper function to seperate an correct the json]-------------------------------------------------------------
+#################################################################################################################################################################
+
+def separate_scripts(pseudocode_string):
+    """
+    Separates a block of Scratch pseudocode into a list of individual scripts.
+
+    This function finds the start of each "hat" block and slices the
+    original string to capture the full code block for each script,
+    providing a more robust and reliable separation.
+
+    Args:
+        pseudocode_string (str): A string containing Scratch pseudocode.
+
+    Returns:
+        list: A list of strings, where each string is a complete,
+              separated script.
+    """
+    # Define the "hat" block patterns with more robust regex.
+    # We use a non-capturing group (?:...) for the patterns.
+    # We use a logical OR (|) to combine them into a single pattern.
+    delimiter_patterns = (
+        r"when green flag clicked|when flag clicked|when \S+ key pressed|"
+        r"when this sprite clicked|when backdrop switches to \[.*?\]|"
+        r"when I receive \[.*?\]|when \[.*?\] > \[.*?\]"
+    )
+
+    # Use re.finditer to get an iterator of all hat block matches.
+    # The `re.DOTALL` flag allows the '.' to match newlines.
+    matches = list(re.finditer(delimiter_patterns, pseudocode_string, flags=re.DOTALL | re.IGNORECASE))
+
+    scripts = []
+    # If no matches are found, return an empty list.
+    if not matches:
+        return []
+
+    # Iterate through the matches to slice the original string.
+    for i in range(len(matches)):
+        start = matches[i].start()
+        end = matches[i+1].start() if i + 1 < len(matches) else len(pseudocode_string)
+        
+        # Slice the pseudocode string from the start of one match to the start
+        # of the next, or to the end of the string.
+        script = pseudocode_string[start:end]
+        scripts.append(script.strip())
+    
+    return scripts
+
+def transform_logic_to_action_flow(source_data, description=""):
+    """
+    Transforms a 'refined_logic' JSON structure into an 'action_overall_flow' structure.
+
+    Args:
+        source_data (dict): The input dictionary with 'refined_logic', 'name_variable',
+                             and 'pseudocode' keys.
+        description (str): A description to be added to the output structure.
+
+    Returns:
+        dict: A dictionary in the desired 'action_overall_flow' format.
+    """
+    # Check if the required keys exist in the source data
+    if "refined_logic" not in source_data or \
+       "name_variable" not in source_data["refined_logic"] or \
+       "pseudocode" not in source_data["refined_logic"]:
+        raise ValueError("Input dictionary is missing required keys: 'refined_logic', 'name_variable', or 'pseudocode'.")
+
+    # Extract the name and the pseudocode list from the source data
+    name_variable = source_data["refined_logic"]["name_variable"]
+    pseudocode_list = source_data["refined_logic"]["pseudocode"]
+
+    # Transform the list of pseudocode strings into a list of dictionaries
+    # with the "logic" key.
+    plans_list = [{"logic": logic_block} for logic_block in pseudocode_list]
+
+    # Construct the final nested dictionary structure
+    transformed_data = {
+        "action_overall_flow": {
+            name_variable: {
+                "description": description,
+                "plans": plans_list
+            }
+        }
+    }
+
+    return transformed_data
+
 #################################################################################################################################################################
 #--------------------------------------------------[Helper main function]----------------------------------------------------------------------------------------
 #################################################################################################################################################################
@@ -3115,11 +3384,12 @@ when I receive [Game Start v]
 end
 """
 # print(pseudo_code)
-# generated_output_json, initial_opcode_occurrences = generate_blocks_from_opcodes(initial_opcode_counts, all_block_definitions)
+# opcode_counts_result = analyze_opcode_counts(pseudo_code)
+# generated_output_json, initial_opcode_occurrences = generate_blocks_from_opcodes(opcode_counts_result, all_block_definitions)
 # all_generated_blocks = generate_plan(generated_output_json, initial_opcode_occurrences, pseudo_code)
 # processed_blocks= process_scratch_blocks(all_generated_blocks, generated_output_json)
 # renamed_blocks, renamed_counts = rename_blocks(processed_blocks, initial_opcode_occurrences)
-# #print(all_generated_blocks)
+# print(opcode_counts_result)
 # print("--------------\n\n")
 # print(processed_blocks)
 # print("--------------\n\n")