@codesys/mcp-toolkit 1.5.8 → 2.0.0-alpha.0

package/dist/scripts/create_pou.py

@@ -1,102 +0,0 @@
-import sys, scriptengine as script_engine, os, traceback
-
-# Import ensure_project_open function from the template
-# This will be prepended by the script loader
-def ensure_project_open(target_project_path):
-    # Function implementation will be included from ensure_project_open.py
-    pass
-
-# Import find_object_by_path function from the template
-# This will be prepended by the script loader
-def find_object_by_path_robust(start_node, full_path, target_type_name="object"):
-    # Function implementation will be included from find_object_by_path.py
-    pass
-
-# Define required parameters
-POU_NAME = "{POU_NAME}"
-POU_TYPE_STR = "{POU_TYPE_STR}" 
-IMPL_LANGUAGE_STR = "{IMPL_LANGUAGE_STR}"
-PARENT_PATH_REL = "{PARENT_PATH}"
-
-# Define the global PROJECT_FILE_PATH for compatibility with ensure_project_open
-# When this script is embedded in other scripts
-if 'PROJECT_FILE_PATH' not in globals():
-    PROJECT_FILE_PATH = "{PROJECT_FILE_PATH}"
-
-pou_type_map = { 
-    "Program": script_engine.PouType.Program, 
-    "FunctionBlock": script_engine.PouType.FunctionBlock, 
-    "Function": script_engine.PouType.Function 
-}
-# Map common language names to ImplementationLanguages attributes if needed (optional, None usually works)
-# lang_map = { "ST": script_engine.ImplementationLanguage.st, ... }
-
-try:
-    print("DEBUG: create_pou script: Name='%s', Type='%s', Lang='%s', ParentPath='%s', Project='%s'" % (POU_NAME, POU_TYPE_STR, IMPL_LANGUAGE_STR, PARENT_PATH_REL, PROJECT_FILE_PATH))
-    primary_project = ensure_project_open(PROJECT_FILE_PATH)
-    if not POU_NAME: raise ValueError("POU name empty.")
-    if not PARENT_PATH_REL: raise ValueError("Parent path empty.")
-
-    # Resolve POU Type Enum
-    pou_type_enum = pou_type_map.get(POU_TYPE_STR)
-    if not pou_type_enum: raise ValueError("Invalid POU type string: %s. Use Program, FunctionBlock, or Function." % POU_TYPE_STR)
-
-    # Find parent object using the robust function
-    parent_object = find_object_by_path_robust(primary_project, PARENT_PATH_REL, "parent container")
-    if not parent_object: raise ValueError("Parent object not found for path: %s" % PARENT_PATH_REL)
-
-    parent_name = getattr(parent_object, 'get_name', lambda: str(parent_object))()
-    print("DEBUG: Using parent object: %s (Type: %s)" % (parent_name, type(parent_object).__name__))
-
-    # Check if parent object supports creating POUs (should implement ScriptIecLanguageObjectContainer)
-    if not hasattr(parent_object, 'create_pou'):
-        raise TypeError("Parent object '%s' of type %s does not support create_pou." % (parent_name, type(parent_object).__name__))
-
-    # Set language GUID to None (let CODESYS default based on parent/settings)
-    lang_guid = None
-    print("DEBUG: Setting language to None (will use default).")
-    # Example if mapping language string: lang_guid = lang_map.get(IMPL_LANGUAGE_STR, None)
-
-    print("DEBUG: Calling parent_object.create_pou: Name='%s', Type=%s, Lang=%s" % (POU_NAME, pou_type_enum, lang_guid))
-
-    # Call create_pou using keyword arguments
-    new_pou = parent_object.create_pou(
-        name=POU_NAME,
-        type=pou_type_enum,
-        language=lang_guid # Pass None
-    )
-
-    print("DEBUG: parent_object.create_pou returned: %s" % new_pou)
-    if new_pou:
-        new_pou_name = getattr(new_pou, 'get_name', lambda: POU_NAME)()
-        print("DEBUG: POU object created: %s" % new_pou_name)
-
-        # --- SAVE THE PROJECT TO PERSIST THE NEW POU ---
-        try:
-            print("DEBUG: Saving Project...")
-            primary_project.save() # Save the overall project file
-            print("DEBUG: Project saved successfully after POU creation.")
-        except Exception as save_err:
-            print("ERROR: Failed to save Project after POU creation: %s" % save_err)
-            detailed_error = traceback.format_exc()
-            error_message = "Error saving Project after creating POU '%s': %s\\n%s" % (new_pou_name, save_err, detailed_error)
-            print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
-        # --- END SAVING ---
-
-        print("POU Created: %s" % new_pou_name)
-        print("Type: %s" % POU_TYPE_STR)
-        print("Language: %s (Defaulted)" % IMPL_LANGUAGE_STR)
-        print("Parent Path: %s" % PARENT_PATH_REL)
-        print("SCRIPT_SUCCESS: POU created successfully.")
-        sys.exit(0)
-    else:
-        error_message = "Failed to create POU '%s'. create_pou returned None." % POU_NAME
-        print(error_message)
-        print("SCRIPT_ERROR: %s" % error_message)
-        sys.exit(1)
-except Exception as e:
-    detailed_error = traceback.format_exc()
-    error_message = "Error creating POU '%s' in project '%s': %s\\n%s" % (POU_NAME, PROJECT_FILE_PATH, e, detailed_error)
-    print(error_message)
-    print("SCRIPT_ERROR: Error creating POU '%s': %s" % (POU_NAME, e))
-    sys.exit(1)

package/dist/scripts/create_project.py

@@ -1,116 +0,0 @@
-import sys, scriptengine as script_engine, os, shutil, time, traceback
-
-# Direct path assignment - no more raw string handling
-# Paths will be correctly escaped in the template substitution
-TEMPLATE_PROJECT_PATH = '{TEMPLATE_PROJECT_PATH}' 
-PROJECT_FILE_PATH = '{PROJECT_FILE_PATH}'
-# Optional flag to skip opening the project after creation (useful for sessions)
-SKIP_OPEN = '{SKIP_OPEN}' == 'true'
-
-# Define the global PROJECT_FILE_PATH for compatibility with ensure_project_open
-# This is used by some scripts that check the project status
-if 'PROJECT_FILE_PATH' not in globals():
-    globals()['PROJECT_FILE_PATH'] = PROJECT_FILE_PATH
-
-# Print raw paths for debugging
-print("DEBUG: Template path (raw): %s" % repr(TEMPLATE_PROJECT_PATH))
-print("DEBUG: Project path (raw): %s" % repr(PROJECT_FILE_PATH))
-
-print("DEBUG: Processed TEMPLATE_PROJECT_PATH: %s" % TEMPLATE_PROJECT_PATH)
-print("DEBUG: Processed PROJECT_FILE_PATH: %s" % PROJECT_FILE_PATH)
-try:
-    print("DEBUG: Python script create_project (copy from template):")
-    print("DEBUG:   Template Source = %s" % TEMPLATE_PROJECT_PATH)
-    print("DEBUG:   Target Path = %s" % PROJECT_FILE_PATH)
-    if not PROJECT_FILE_PATH: raise ValueError("Target project file path empty.")
-    if not TEMPLATE_PROJECT_PATH: raise ValueError("Template project file path empty.")
-    if not os.path.exists(TEMPLATE_PROJECT_PATH): raise IOError("Template project file not found: %s" % TEMPLATE_PROJECT_PATH)
-
-    # 1. Copy the template project file to the new location
-    target_dir = os.path.dirname(PROJECT_FILE_PATH)
-    print("DEBUG: Target directory path: %s" % target_dir)
-    
-    # More robust directory creation
-    if not os.path.exists(target_dir):
-        try:
-            print("DEBUG: Creating target directory: %s" % target_dir)
-            os.makedirs(target_dir, exist_ok=True)
-            print("DEBUG: Directory creation result - exists after creation: %s" % os.path.exists(target_dir))
-        except Exception as dir_err:
-            print("ERROR: Failed to create directory %s: %s" % (target_dir, dir_err))
-            raise
-    
-    # Check if target file already exists
-    if os.path.exists(PROJECT_FILE_PATH): print("WARN: Target project file already exists, overwriting: %s" % PROJECT_FILE_PATH)
-
-    print("DEBUG: Copying '%s' to '%s'..." % (TEMPLATE_PROJECT_PATH, PROJECT_FILE_PATH))
-    try:
-        # Complete path diagnosis
-        print("DEBUG: Template path absolute: %s" % os.path.abspath(TEMPLATE_PROJECT_PATH))
-        print("DEBUG: Target path absolute: %s" % os.path.abspath(PROJECT_FILE_PATH))
-        print("DEBUG: Template exists: %s" % os.path.exists(TEMPLATE_PROJECT_PATH))
-        print("DEBUG: Target dir exists: %s" % os.path.exists(target_dir))
-        print("DEBUG: Target dir is writable: %s" % os.access(target_dir, os.W_OK))
-        
-        # Perform the copy
-        shutil.copy2(TEMPLATE_PROJECT_PATH, PROJECT_FILE_PATH) # copy2 preserves metadata
-        
-        # Verify copy succeeded
-        if os.path.exists(PROJECT_FILE_PATH):
-            print("DEBUG: File copy VERIFIED - file exists at destination")
-            print("DEBUG: File size at destination: %s bytes" % os.path.getsize(PROJECT_FILE_PATH))
-        else:
-            print("ERROR: Copy seemed to succeed but file does not exist at destination!")
-            raise IOError("File not found at destination after copy: %s" % PROJECT_FILE_PATH)
-    except Exception as copy_err:
-        print("ERROR: Failed to copy file: %s" % copy_err)
-        raise
-        
-    print("DEBUG: File copy complete.")
-
-    # For sessions, we may want to skip opening the project to avoid conflicts
-    if SKIP_OPEN:
-        print("DEBUG: SKIP_OPEN is set to true, skipping project open step.")
-        print("Project Created from Template Copy at: %s" % PROJECT_FILE_PATH)
-        print("SCRIPT_SUCCESS: Project copied from template (open step skipped for session compatibility).")
-        sys.exit(0)
-    
-    # 2. Open the newly copied project file
-    print("DEBUG: Opening the copied project: %s" % PROJECT_FILE_PATH)
-    # Set flags for silent opening
-    update_mode = script_engine.VersionUpdateFlags.NoUpdates | script_engine.VersionUpdateFlags.SilentMode
-    # try:
-    #     update_mode = script_engine.VersionUpdateFlags.NoUpdates | script_engine.VersionUpdateFlags.SilentMode
-    # except AttributeError:
-    #     print("WARN: VersionUpdateFlags not found, using integer flags for open (1 | 2 = 3).")
-    #     update_mode = 3
-
-    try:
-        project = script_engine.projects.open(PROJECT_FILE_PATH, update_flags=update_mode)
-        print("DEBUG: script_engine.projects.open returned: %s" % project)
-        if project:
-            print("DEBUG: Pausing briefly after open...")
-            time.sleep(1.0) # Allow CODESYS to potentially initialize things
-            try:
-                print("DEBUG: Explicitly saving project after opening copy...")
-                project.save();
-                print("DEBUG: Project save after opening copy succeeded.")
-            except Exception as save_err:
-                print("WARN: Explicit save after opening copy failed: %s" % save_err)
-                # Decide if this is critical - maybe not, but good to know.
-            print("Project Created from Template Copy at: %s" % PROJECT_FILE_PATH)
-            print("SCRIPT_SUCCESS: Project copied from template and opened successfully.")
-            sys.exit(0)
-        else:
-            error_message = "Failed to open project copy %s after copying template %s. projects.open returned None." % (PROJECT_FILE_PATH, TEMPLATE_PROJECT_PATH)
-            print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
-    except Exception as open_err:
-        print("WARN: Error opening project after creation: %s" % open_err)
-        # Even though we couldn't open it, the project was still created successfully
-        print("Project Created from Template Copy at: %s (but could not be opened automatically)" % PROJECT_FILE_PATH)
-        print("SCRIPT_SUCCESS: Project copied from template (but open operation failed: %s)." % open_err)
-        sys.exit(0)
-except Exception as e:
-    detailed_error = traceback.format_exc()
-    error_message = "Error creating project '%s' from template '%s': %s\\n%s" % (PROJECT_FILE_PATH, TEMPLATE_PROJECT_PATH, e, detailed_error)
-    print(error_message); print("SCRIPT_ERROR: Error copying/opening template: %s" % e); sys.exit(1)

package/dist/scripts/create_property.py

@@ -1,78 +0,0 @@
-import sys, scriptengine as script_engine, os, traceback
-
-# Import ensure_project_open function from the template
-# This will be prepended by the script loader
-def ensure_project_open(target_project_path):
-    # Function implementation will be included from ensure_project_open.py
-    pass
-
-# Import find_object_by_path function from the template
-# This will be prepended by the script loader
-def find_object_by_path_robust(start_node, full_path, target_type_name="object"):
-    # Function implementation will be included from find_object_by_path.py
-    pass
-
-PARENT_POU_FULL_PATH = "{PARENT_POU_FULL_PATH}" # e.g., "Application/MyFB"
-PROPERTY_NAME = "{PROPERTY_NAME}"
-PROPERTY_TYPE = "{PROPERTY_TYPE}"
-# Optional: Language for Getter/Setter (usually defaults to ST)
-# LANG_GUID_STR = "{LANG_GUID_STR}" # Example if needed
-
-try:
-    print("DEBUG: create_property script: ParentPOU='%s', Name='%s', Type='%s', Project='%s'" % (PARENT_POU_FULL_PATH, PROPERTY_NAME, PROPERTY_TYPE, PROJECT_FILE_PATH))
-    primary_project = ensure_project_open(PROJECT_FILE_PATH)
-    if not PARENT_POU_FULL_PATH: raise ValueError("Parent POU full path empty.")
-    if not PROPERTY_NAME: raise ValueError("Property name empty.")
-    if not PROPERTY_TYPE: raise ValueError("Property type empty.")
-
-    # Find the parent POU object
-    parent_pou_object = find_object_by_path_robust(primary_project, PARENT_POU_FULL_PATH, "parent POU")
-    if not parent_pou_object: raise ValueError("Parent POU object not found: %s" % PARENT_POU_FULL_PATH)
-
-    parent_pou_name = getattr(parent_pou_object, 'get_name', lambda: PARENT_POU_FULL_PATH)()
-    print("DEBUG: Found Parent POU object: %s" % parent_pou_name)
-
-    # Check if parent object supports creating properties (should implement ScriptIecLanguageMemberContainer)
-    if not hasattr(parent_pou_object, 'create_property'):
-         raise TypeError("Parent object '%s' of type %s does not support create_property." % (parent_pou_name, type(parent_pou_object).__name__))
-
-    # Default language to None (usually ST)
-    lang_guid = None
-    print("DEBUG: Calling create_property: Name='%s', Type='%s', Lang=%s" % (PROPERTY_NAME, PROPERTY_TYPE, lang_guid))
-
-    # Call the create_property method ON THE PARENT POU
-    new_property_object = parent_pou_object.create_property(
-        name=PROPERTY_NAME,
-        return_type=PROPERTY_TYPE,
-        language=lang_guid # Pass None to use default
-    )
-
-    if new_property_object:
-        new_prop_name = getattr(new_property_object, 'get_name', lambda: PROPERTY_NAME)()
-        print("DEBUG: Property object created: %s" % new_prop_name)
-
-        # --- SAVE THE PROJECT TO PERSIST THE NEW PROPERTY OBJECT ---
-        try:
-            print("DEBUG: Saving Project (after property creation)...")
-            primary_project.save()
-            print("DEBUG: Project saved successfully after property creation.")
-        except Exception as save_err:
-            print("ERROR: Failed to save Project after creating property: %s" % save_err)
-            detailed_error = traceback.format_exc()
-            error_message = "Error saving Project after creating property '%s': %s\\n%s" % (PROPERTY_NAME, save_err, detailed_error)
-            print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
-        # --- END SAVING ---
-
-        print("Property Created: %s" % new_prop_name)
-        print("Parent POU: %s" % PARENT_POU_FULL_PATH)
-        print("Type: %s" % PROPERTY_TYPE)
-        print("SCRIPT_SUCCESS: Property created successfully.")
-        sys.exit(0)
-    else:
-         error_message = "Failed to create property '%s' under '%s'. create_property returned None." % (PROPERTY_NAME, parent_pou_name)
-         print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
-
-except Exception as e:
-    detailed_error = traceback.format_exc()
-    error_message = "Error creating property '%s' under POU '%s' in project '%s': %s\\n%s" % (PROPERTY_NAME, PARENT_POU_FULL_PATH, PROJECT_FILE_PATH, e, detailed_error)
-    print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)

package/dist/scripts/ensure_project_open.py

@@ -1,154 +0,0 @@
-import sys
-import scriptengine as script_engine
-import os
-import time
-import traceback
-
-# --- Function to ensure the correct project is open ---
-MAX_RETRIES = 3
-RETRY_DELAY = 2.0 # seconds (use float for time.sleep)
-
-def ensure_project_open(target_project_path):
-    print("DEBUG: Ensuring project is open: %s" % target_project_path)
-    # Normalize target path once
-    normalized_target_path = os.path.normcase(os.path.abspath(target_project_path))
-
-    for attempt in range(MAX_RETRIES):
-        print("DEBUG: Ensure project attempt %d/%d for %s" % (attempt + 1, MAX_RETRIES, normalized_target_path))
-        primary_project = None
-        try:
-            # Getting primary project might fail if CODESYS instance is unstable
-            primary_project = script_engine.projects.primary
-        except Exception as primary_err:
-             print("WARN: Error getting primary project: %s. Assuming none." % primary_err)
-             # traceback.print_exc() # Optional: Print stack trace for this error
-             primary_project = None
-
-        current_project_path = ""
-        project_ok = False # Flag to check if target is confirmed primary and accessible
-
-        if primary_project:
-            try:
-                # Getting path should be relatively safe if primary_project object exists
-                current_project_path = os.path.normcase(os.path.abspath(primary_project.path))
-                print("DEBUG: Current primary project path: %s" % current_project_path)
-                if current_project_path == normalized_target_path:
-                    # Found the right project as primary, now check if it's usable
-                    print("DEBUG: Target project path matches primary. Checking access...")
-                    try:
-                         # Try a relatively safe operation to confirm object usability
-                         # Getting children count is a reasonable check
-                         _ = len(primary_project.get_children(False))
-                         print("DEBUG: Target project '%s' is primary and accessible." % target_project_path)
-                         project_ok = True
-                         return primary_project # SUCCESS CASE 1: Already open and accessible
-                    except Exception as access_err:
-                         # Project found, but accessing it failed. Might be unstable.
-                         print("WARN: Primary project access check failed for '%s': %s. Will attempt reopen." % (current_project_path, access_err))
-                         # traceback.print_exc() # Optional: Print stack trace
-                         primary_project = None # Force reopen by falling through
-                else:
-                    # A *different* project is primary
-                     print("DEBUG: Primary project is '%s', not the target '%s'." % (current_project_path, normalized_target_path))
-                     # Consider closing the wrong project if causing issues, but for now, just open target
-                     # try:
-                     #     print("DEBUG: Closing incorrect primary project '%s'..." % current_project_path)
-                     #     primary_project.close() # Be careful with unsaved changes
-                     # except Exception as close_err:
-                     #     print("WARN: Failed to close incorrect primary project: %s" % close_err)
-                     primary_project = None # Force open target project
-
-            except Exception as path_err:
-                 # Failed even to get the path of the supposed primary project
-                 print("WARN: Could not get path of current primary project: %s. Assuming not the target." % path_err)
-                 # traceback.print_exc() # Optional: Print stack trace
-                 primary_project = None # Force open target project
-
-        # If target project not confirmed as primary and accessible, attempt to open/reopen
-        if not project_ok:
-            # Log clearly whether we are opening initially or reopening
-            if primary_project is None and current_project_path == "":
-                print("DEBUG: No primary project detected. Attempting to open target: %s" % target_project_path)
-            elif primary_project is None and current_project_path != "":
-                 print("DEBUG: Primary project was '%s' but failed access check or needed close. Attempting to open target: %s" % (current_project_path, target_project_path))
-            else: # Includes cases where wrong project was open
-                print("DEBUG: Target project not primary or initial check failed. Attempting to open/reopen: %s" % target_project_path)
-
-            try:
-                # Set flags for silent opening, handle potential attribute errors
-                update_mode = script_engine.VersionUpdateFlags.NoUpdates | script_engine.VersionUpdateFlags.SilentMode
-                # try:
-                #     update_mode = script_engine.VersionUpdateFlags.NoUpdates | script_engine.VersionUpdateFlags.SilentMode
-                # except AttributeError:
-                #     print("WARN: VersionUpdateFlags not found, using integer flags for open (1 | 2 = 3).")
-                #     update_mode = 3 # 1=NoUpdates, 2=SilentMode
-
-                opened_project = None
-                try:
-                     # The actual open call
-                     print("DEBUG: Calling script_engine.projects.open('%s', update_flags=%s)..." % (target_project_path, update_mode))
-                     opened_project = script_engine.projects.open(target_project_path, update_flags=update_mode)
-
-                     if not opened_project:
-                         # This is a critical failure if open returns None without exception
-                         print("ERROR: projects.open returned None for %s on attempt %d" % (target_project_path, attempt + 1))
-                         # Allow retry loop to continue
-                     else:
-                         # Open call returned *something*, let's verify
-                         print("DEBUG: projects.open call returned an object for: %s" % target_project_path)
-                         print("DEBUG: Pausing for stabilization after open...")
-                         time.sleep(RETRY_DELAY) # Give CODESYS time
-                         # Re-verify: Is the project now primary and accessible?
-                         recheck_primary = None
-                         try: recheck_primary = script_engine.projects.primary
-                         except Exception as recheck_primary_err: print("WARN: Error getting primary project after reopen: %s" % recheck_primary_err)
-
-                         if recheck_primary:
-                              recheck_path = ""
-                              try: # Getting path might fail
-                                  recheck_path = os.path.normcase(os.path.abspath(recheck_primary.path))
-                              except Exception as recheck_path_err:
-                                  print("WARN: Failed to get path after reopen: %s" % recheck_path_err)
-
-                              if recheck_path == normalized_target_path:
-                                   print("DEBUG: Target project confirmed as primary after reopening.")
-                                   try: # Final sanity check
-                                       _ = len(recheck_primary.get_children(False))
-                                       print("DEBUG: Reopened project basic access confirmed.")
-                                       return recheck_primary # SUCCESS CASE 2: Successfully opened/reopened
-                                   except Exception as access_err_reopen:
-                                        print("WARN: Reopened project (%s) basic access check failed: %s." % (normalized_target_path, access_err_reopen))
-                                        # traceback.print_exc() # Optional
-                                        # Allow retry loop to continue
-                              else:
-                                   print("WARN: Different project is primary after reopening! Expected '%s', got '%s'." % (normalized_target_path, recheck_path))
-                                   # Allow retry loop to continue, maybe it fixes itself
-                         else:
-                               print("WARN: No primary project found after reopening attempt %d!" % (attempt+1))
-                               # Allow retry loop to continue
-
-                except Exception as open_err:
-                     # Catch errors during the open call itself
-                     print("ERROR: Exception during projects.open call on attempt %d: %s" % (attempt + 1, open_err))
-                     traceback.print_exc() # Crucial for diagnosing open failures
-                     # Allow retry loop to continue
-
-            except Exception as outer_open_err:
-                 # Catch errors in the flag setup etc.
-                 print("ERROR: Unexpected error during open setup/logic attempt %d: %s" % (attempt + 1, outer_open_err))
-                 traceback.print_exc()
-
-        # If we didn't return successfully in this attempt, wait before retrying
-        if attempt < MAX_RETRIES - 1:
-            print("DEBUG: Ensure project attempt %d did not succeed. Waiting %f seconds..." % (attempt + 1, RETRY_DELAY))
-            time.sleep(RETRY_DELAY)
-        else: # Last attempt failed
-             print("ERROR: Failed all ensure_project_open attempts for %s." % normalized_target_path)
-
-
-    # If all retries fail after the loop
-    raise RuntimeError("Failed to ensure project '%s' is open and accessible after %d attempts." % (target_project_path, MAX_RETRIES))
-# --- End of function ---
-
-# Placeholder for the project file path (must be set in scripts using this snippet)
-PROJECT_FILE_PATH = r"{PROJECT_FILE_PATH}"

package/dist/scripts/find_object_by_path.py

@@ -1,111 +0,0 @@
-import traceback
-# --- Find object by path function ---
-def find_object_by_path_robust(start_node, full_path, target_type_name="object"):
-    print("DEBUG: Finding %s by path: '%s'" % (target_type_name, full_path))
-    normalized_path = full_path.replace('\\\\', '/').strip('/')
-    path_parts = normalized_path.split('/')
-    if not path_parts:
-        print("ERROR: Path is empty.")
-        return None
-
-    # Determine the actual starting node (project or application)
-    project = start_node # Assume start_node is project initially
-    if not hasattr(start_node, 'active_application') and hasattr(start_node, 'project'):
-         # If start_node is not project but has project ref (e.g., an application), get the project
-         try: project = start_node.project
-         except Exception as proj_ref_err:
-             print("WARN: Could not get project reference from start_node: %s" % proj_ref_err)
-             # Proceed assuming start_node might be the project anyway or search fails
-
-    # Try to get the application object robustly if we think we have the project
-    app = None
-    if hasattr(project, 'active_application'):
-        try: app = project.active_application
-        except Exception: pass # Ignore errors getting active app
-        if not app:
-            try:
-                 apps = project.find("Application", True) # Search recursively
-                 if apps: app = apps[0]
-            except Exception: pass
-
-    # Check if the first path part matches the application name
-    app_name_lower = ""
-    if app:
-        try: app_name_lower = (app.get_name() or "application").lower()
-        except Exception: app_name_lower = "application" # Fallback
-
-    # Decide where to start the traversal
-    current_obj = start_node # Default to the node passed in
-    if hasattr(project, 'active_application'): # Only adjust if start_node was likely the project
-        if app and path_parts[0].lower() == app_name_lower:
-             print("DEBUG: Path starts with Application name '%s'. Beginning search there." % path_parts[0])
-             current_obj = app
-             path_parts = path_parts[1:] # Consume the app name part
-             # If path was *only* the application name
-             if not path_parts:
-                 print("DEBUG: Target path is the Application object itself.")
-                 return current_obj
-        else:
-            print("DEBUG: Path does not start with Application name. Starting search from project root.")
-            current_obj = project # Start search from the project root
-    else:
-         print("DEBUG: Starting search from originally provided node.")
-
-
-    # Traverse the remaining path parts
-    parent_path_str = getattr(current_obj, 'get_name', lambda: str(current_obj))() # Safer name getting
-
-    for i, part_name in enumerate(path_parts):
-        is_last_part = (i == len(path_parts) - 1)
-        print("DEBUG: Searching for part [%d/%d]: '%s' under '%s'" % (i+1, len(path_parts), part_name, parent_path_str))
-        found_in_parent = None
-        try:
-            # Prioritize non-recursive find for direct children
-            children_of_current = current_obj.get_children(False)
-            print("DEBUG: Found %d direct children under '%s'." % (len(children_of_current), parent_path_str))
-            for child in children_of_current:
-                 child_name = getattr(child, 'get_name', lambda: None)() # Safer name getting
-                 # print("DEBUG: Checking child: '%s'" % child_name) # Verbose
-                 if child_name == part_name:
-                     found_in_parent = child
-                     print("DEBUG: Found direct child matching '%s'." % part_name)
-                     break # Found direct child, stop searching children
-
-            # If not found directly, AND it's the last part, try recursive find from current parent
-            if not found_in_parent and is_last_part:
-                 print("DEBUG: Direct find failed for last part '%s'. Trying recursive find under '%s'." % (part_name, parent_path_str))
-                 found_recursive_list = current_obj.find(part_name, True) # Recursive find
-                 if found_recursive_list:
-                     # Maybe add a check here if multiple are found?
-                     found_in_parent = found_recursive_list[0] # Take the first match
-                     print("DEBUG: Found last part '%s' recursively." % part_name)
-                 else:
-                     print("DEBUG: Recursive find also failed for last part '%s'." % part_name)
-
-            # Update current object if found
-            if found_in_parent:
-                current_obj = found_in_parent
-                parent_path_str = getattr(current_obj, 'get_name', lambda: part_name)() # Safer name getting
-                print("DEBUG: Stepped into '%s'." % parent_path_str)
-            else:
-                # If not found at any point, the path is invalid from this parent
-                print("ERROR: Path part '%s' not found under '%s'." % (part_name, parent_path_str))
-                return None # Path broken
-
-        except Exception as find_err:
-            print("ERROR: Exception while searching for '%s' under '%s': %s" % (part_name, parent_path_str, find_err))
-            traceback.print_exc()
-            return None # Error during search
-
-    # Final verification (optional but recommended): Check if the found object's name matches the last part
-    final_expected_name = full_path.split('/')[-1]
-    found_final_name = getattr(current_obj, 'get_name', lambda: None)() # Safer name getting
-
-    if found_final_name == final_expected_name:
-        print("DEBUG: Final %s found and name verified for path '%s': %s" % (target_type_name, full_path, found_final_name))
-        return current_obj
-    else:
-        print("ERROR: Traversal ended on object '%s' but expected final name was '%s'." % (found_final_name, final_expected_name))
-        return None # Name mismatch implies target not found as expected
-
-# --- End of find object function ---

package/dist/scripts/get_pou_code.py

@@ -1,91 +0,0 @@
-import sys, scriptengine as script_engine, os, traceback
-
-# Import ensure_project_open function from the template
-# This will be prepended by the script loader
-def ensure_project_open(target_project_path):
-    # Function implementation will be included from ensure_project_open.py
-    pass
-
-# Import find_object_by_path function from the template
-# This will be prepended by the script loader
-def find_object_by_path_robust(start_node, full_path, target_type_name="object"):
-    # Function implementation will be included from find_object_by_path.py
-    pass
-
-POU_FULL_PATH = "{POU_FULL_PATH}" 
-CODE_START_MARKER = "### POU CODE START ###"
-CODE_END_MARKER = "### POU CODE END ###"
-DECL_START_MARKER = "### POU DECLARATION START ###"
-DECL_END_MARKER = "### POU DECLARATION END ###"
-IMPL_START_MARKER = "### POU IMPLEMENTATION START ###"
-IMPL_END_MARKER = "### POU IMPLEMENTATION END ###"
-
-try:
-    print("DEBUG: Getting code: POU_FULL_PATH='%s', Project='%s'" % (POU_FULL_PATH, PROJECT_FILE_PATH))
-    primary_project = ensure_project_open(PROJECT_FILE_PATH)
-    if not POU_FULL_PATH: raise ValueError("POU full path empty.")
-
-    # Find the target POU/Method/Property object
-    target_object = find_object_by_path_robust(primary_project, POU_FULL_PATH, "target object")
-    if not target_object: raise ValueError("Target object not found using path: %s" % POU_FULL_PATH)
-
-    target_name = getattr(target_object, 'get_name', lambda: POU_FULL_PATH)()
-    print("DEBUG: Found target object: %s" % target_name)
-
-    declaration_code = ""; implementation_code = ""
-
-    # --- Get Declaration Part ---
-    if hasattr(target_object, 'textual_declaration'):
-        decl_obj = target_object.textual_declaration
-        if decl_obj and hasattr(decl_obj, 'text'):
-            try:
-                declaration_code = decl_obj.text
-                print("DEBUG: Got declaration text.")
-            except Exception as decl_read_err:
-                print("ERROR: Failed to read declaration text: %s" % decl_read_err)
-                declaration_code = "/* ERROR reading declaration: %s */" % decl_read_err
-        else:
-            print("WARN: textual_declaration exists but is None or has no 'text' attribute.")
-    else:
-        print("WARN: No textual_declaration attribute.")
-
-    # --- Get Implementation Part ---
-    if hasattr(target_object, 'textual_implementation'):
-        impl_obj = target_object.textual_implementation
-        if impl_obj and hasattr(impl_obj, 'text'):
-            try:
-                implementation_code = impl_obj.text
-                print("DEBUG: Got implementation text.")
-            except Exception as impl_read_err:
-                print("ERROR: Failed to read implementation text: %s" % impl_read_err)
-                implementation_code = "/* ERROR reading implementation: %s */" % impl_read_err
-        else:
-            print("WARN: textual_implementation exists but is None or has no 'text' attribute.")
-    else:
-        print("WARN: No textual_implementation attribute.")
-
-
-    print("Code retrieved for: %s" % target_name)
-    # Print declaration between markers, ensuring markers are on separate lines
-    print("\\n" + DECL_START_MARKER)
-    print(declaration_code)
-    print(DECL_END_MARKER + "\\n")
-    # Print implementation between markers
-    print(IMPL_START_MARKER)
-    print(implementation_code)
-    print(IMPL_END_MARKER + "\\n")
-
-    # --- LEGACY MARKERS for backward compatibility if needed ---
-    # Combine both for old marker format, adding a separator line
-    # legacy_combined_code = declaration_code + "\\n\\n// Implementation\\n" + implementation_code
-    # print(CODE_START_MARKER); print(legacy_combined_code); print(CODE_END_MARKER)
-    # --- END LEGACY ---
-
-    print("SCRIPT_SUCCESS: Code retrieved.")
-    sys.exit(0)
-except Exception as e:
-    detailed_error = traceback.format_exc()
-    error_message = "Error getting code for object '%s' in project '%s': %s\\n%s" % (POU_FULL_PATH, PROJECT_FILE_PATH, e, detailed_error)
-    print(error_message)
-    print("SCRIPT_ERROR: %s" % error_message)
-    sys.exit(1)