@codesys/mcp-toolkit 1.1.6 → 1.1.8

package/dist/scripts/find_object_by_path.py

@@ -0,0 +1,111 @@
+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

@@ -0,0 +1,91 @@
+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)

package/dist/scripts/get_project_structure.py

@@ -0,0 +1,72 @@
+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
+
+def get_object_structure(obj, indent=0, max_depth=10): # Add max_depth
+    lines = []; indent_str = "  " * indent
+    if indent > max_depth:
+        lines.append("%s- Max recursion depth reached." % indent_str)
+        return lines
+    try:
+        name = "Unnamed"; obj_type = type(obj).__name__
+        guid_str = ""
+        folder_str = ""
+        try:
+            name = getattr(obj, 'get_name', lambda: "Unnamed")() or "Unnamed" # Safer get_name
+            if hasattr(obj, 'guid'): guid_str = " {%s}" % obj.guid
+            if hasattr(obj, 'is_folder') and obj.is_folder: folder_str = " [Folder]"
+        except Exception as name_err:
+             print("WARN: Error getting name/guid/folder status for an object: %s" % name_err)
+             name = "!!! Error Getting Name !!!"
+
+        lines.append("%s- %s (%s)%s%s" % (indent_str, name, obj_type, folder_str, guid_str))
+
+        # Get children only if the object potentially has them
+        children = []
+        can_have_children = hasattr(obj, 'get_children') and (
+            not hasattr(obj, 'is_folder') or # If it's not clear if it's a folder (e.g., project root)
+            (hasattr(obj, 'is_folder') and obj.is_folder) or # If it is a folder
+             # Add known container types explicitly, check marker interfaces too
+             hasattr(obj, 'is_project') or hasattr(obj, 'is_application') or hasattr(obj, 'is_device') or hasattr(obj,'is_pou')
+        )
+
+        if can_have_children:
+            try:
+                children = obj.get_children(False)
+                # print("DEBUG: %s has %d children" % (name, len(children))) # Verbose
+            except Exception as get_child_err:
+                lines.append("%s  ERROR getting children: %s" % (indent_str, get_child_err))
+                # traceback.print_exc() # Optional
+
+        for child in children:
+            lines.extend(get_object_structure(child, indent + 1, max_depth)) # Recurse
+
+    except Exception as e:
+        lines.append("%s- Error processing node: %s" % (indent_str, e))
+        traceback.print_exc() # Print detailed error for this node
+    return lines
+    
+try:
+    print("DEBUG: Getting structure for: %s" % PROJECT_FILE_PATH)
+    primary_project = ensure_project_open(PROJECT_FILE_PATH)
+    project_name = os.path.basename(PROJECT_FILE_PATH)
+    print("DEBUG: Getting structure for project: %s" % project_name)
+    # Use the project object obtained from ensure_project_open
+    structure_list = get_object_structure(primary_project, max_depth=15) # Set a reasonable depth
+    structure_output = "\\n".join(structure_list)
+    # Ensure markers are printed distinctly
+    print("\\n--- PROJECT STRUCTURE START ---")
+    print(structure_output)
+    print("--- PROJECT STRUCTURE END ---\\n")
+    print("SCRIPT_SUCCESS: Project structure retrieved.")
+    sys.exit(0)
+except Exception as e:
+    detailed_error = traceback.format_exc()
+    error_message = "Error getting structure for %s: %s\\n%s" % (PROJECT_FILE_PATH, e, detailed_error)
+    print(error_message)
+    print("SCRIPT_ERROR: %s" % error_message)
+    sys.exit(1)

package/dist/scripts/open_project.py

@@ -0,0 +1,25 @@
+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
+
+try:
+    project = ensure_project_open(PROJECT_FILE_PATH)
+    # Get name from object if possible, otherwise use path basename
+    proj_name = "Unknown"
+    try:
+        if project: proj_name = project.get_name() or os.path.basename(PROJECT_FILE_PATH)
+        else: proj_name = os.path.basename(PROJECT_FILE_PATH) + " (ensure_project_open returned None?)"
+    except Exception:
+        proj_name = os.path.basename(PROJECT_FILE_PATH) + " (name retrieval failed)"
+    print("Project Opened: %s" % proj_name)
+    print("SCRIPT_SUCCESS: Project opened successfully.")
+    sys.exit(0)
+except Exception as e:
+    error_message = "Error opening project %s: %s" % (PROJECT_FILE_PATH, e)
+    print(error_message)
+    traceback.print_exc()
+    print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)

package/dist/scripts/save_project.py

@@ -0,0 +1,29 @@
+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
+
+try:
+    primary_project = ensure_project_open(PROJECT_FILE_PATH)
+    # Get name from object if possible, otherwise use path basename
+    project_name = "Unknown"
+    try:
+        if primary_project: project_name = primary_project.get_name() or os.path.basename(PROJECT_FILE_PATH)
+        else: project_name = os.path.basename(PROJECT_FILE_PATH) + " (ensure_project_open returned None?)"
+    except Exception:
+        project_name = os.path.basename(PROJECT_FILE_PATH) + " (name retrieval failed)"
+
+    print("DEBUG: Saving project: %s (%s)" % (project_name, PROJECT_FILE_PATH))
+    primary_project.save()
+    print("DEBUG: project.save() executed.")
+    print("Project Saved: %s" % project_name)
+    print("SCRIPT_SUCCESS: Project saved successfully.")
+    sys.exit(0)
+except Exception as e:
+    error_message = "Error saving project %s: %s" % (PROJECT_FILE_PATH, e)
+    print(error_message)
+    traceback.print_exc()
+    print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)

package/dist/scripts/set_pou_code.py

@@ -0,0 +1,104 @@
+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}" # Expecting format like "Application/MyPOU" or "Folder/SubFolder/MyPOU"
+DECLARATION_CONTENT = """{DECLARATION_CONTENT}"""
+IMPLEMENTATION_CONTENT = """{IMPLEMENTATION_CONTENT}"""
+
+try:
+    print("DEBUG: set_pou_code script: 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)
+
+    # --- Set Declaration Part ---
+    declaration_updated = False
+    # Check if the content is actually provided (might be None/empty if only impl is set)
+    has_declaration_content = 'DECLARATION_CONTENT' in locals() or 'DECLARATION_CONTENT' in globals()
+    if has_declaration_content and DECLARATION_CONTENT is not None: # Check not None
+        if hasattr(target_object, 'textual_declaration'):
+            decl_obj = target_object.textual_declaration
+            if decl_obj and hasattr(decl_obj, 'replace'):
+                try:
+                    print("DEBUG: Accessing textual_declaration...")
+                    decl_obj.replace(DECLARATION_CONTENT)
+                    print("DEBUG: Set declaration text using replace().")
+                    declaration_updated = True
+                except Exception as decl_err:
+                    print("ERROR: Failed to set declaration text: %s" % decl_err)
+                    traceback.print_exc() # Print stack trace for detailed error
+            else:
+                 print("WARN: Target '%s' textual_declaration attribute is None or does not have replace(). Skipping declaration update." % target_name)
+        else:
+            print("WARN: Target '%s' does not have textual_declaration attribute. Skipping declaration update." % target_name)
+    else:
+         print("DEBUG: Declaration content not provided or is None. Skipping declaration update.")
+
+
+    # --- Set Implementation Part ---
+    implementation_updated = False
+    has_implementation_content = 'IMPLEMENTATION_CONTENT' in locals() or 'IMPLEMENTATION_CONTENT' in globals()
+    if has_implementation_content and IMPLEMENTATION_CONTENT is not None: # Check not None
+        if hasattr(target_object, 'textual_implementation'):
+            impl_obj = target_object.textual_implementation
+            if impl_obj and hasattr(impl_obj, 'replace'):
+                try:
+                    print("DEBUG: Accessing textual_implementation...")
+                    impl_obj.replace(IMPLEMENTATION_CONTENT)
+                    print("DEBUG: Set implementation text using replace().")
+                    implementation_updated = True
+                except Exception as impl_err:
+                     print("ERROR: Failed to set implementation text: %s" % impl_err)
+                     traceback.print_exc() # Print stack trace for detailed error
+            else:
+                 print("WARN: Target '%s' textual_implementation attribute is None or does not have replace(). Skipping implementation update." % target_name)
+        else:
+            print("WARN: Target '%s' does not have textual_implementation attribute. Skipping implementation update." % target_name)
+    else:
+        print("DEBUG: Implementation content not provided or is None. Skipping implementation update.")
+
+
+    # --- SAVE THE PROJECT TO PERSIST THE CODE CHANGE ---
+    # Only save if something was actually updated to avoid unnecessary saves
+    if declaration_updated or implementation_updated:
+        try:
+            print("DEBUG: Saving Project (after code change)...")
+            primary_project.save() # Save the overall project file
+            print("DEBUG: Project saved successfully after code change.")
+        except Exception as save_err:
+            print("ERROR: Failed to save Project after setting code: %s" % save_err)
+            detailed_error = traceback.format_exc()
+            error_message = "Error saving Project after code change for '%s': %s\\n%s" % (target_name, save_err, detailed_error)
+            print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
+    else:
+         print("DEBUG: No code parts were updated, skipping project save.")
+    # --- END SAVING ---
+
+    print("Code Set For: %s" % target_name)
+    print("Path: %s" % POU_FULL_PATH)
+    print("SCRIPT_SUCCESS: Declaration and/or implementation set successfully.")
+    sys.exit(0)
+
+except Exception as e:
+    detailed_error = traceback.format_exc()
+    error_message = "Error setting 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)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codesys/mcp-toolkit",
-  "version": "1.1.6",
+  "version": "1.1.8",
   "description": "Model Context Protocol (MCP) server for CODESYS automation platform",
   "main": "dist/server.js",
   "bin": {
@@ -8,7 +8,9 @@
   },
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "tsc",
+    "prebuild": "rm -rf dist",
+    "build": "tsc && npm run copy-scripts",
+    "copy-scripts": "mkdir -p dist/scripts && cp -r src/scripts/* dist/scripts/",
     "start": "node ./dist/server.js"
   },
   "keywords": [
@@ -33,6 +35,16 @@
   "engines": {
     "node": ">=18.0.0"
   },
+  "files": [
+    "dist/",
+    "src/scripts/",
+    "docs/",
+    "examples/",
+    "CHANGELOG.md",
+    "LICENSE",
+    "README.md",
+    "scriptDoc.txt"
+  ],
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.10.2",
     "axios": "^1.6.8",

package/src/scripts/check_status.py

@@ -0,0 +1,21 @@
+import sys, scriptengine as script_engine, os, traceback
+project_open = False; project_name = "No project open"; project_path = "N/A"; scripting_ok = False
+try:
+    scripting_ok = True; primary_project = script_engine.projects.primary
+    if primary_project:
+        project_open = True
+        try:
+            project_path = os.path.normcase(os.path.abspath(primary_project.path))
+            try:
+                 project_name = primary_project.get_name() # Might fail
+                 if not project_name: project_name = "Unnamed (path: %s)" % os.path.basename(project_path)
+            except: project_name = "Unnamed (path: %s)" % os.path.basename(project_path)
+        except Exception as e_path: project_path = "N/A (Error: %s)" % e_path; project_name = "Unnamed (Path Error)"
+    print("Project Open: %s" % project_open); print("Project Name: %s" % project_name)
+    print("Project Path: %s" % project_path); print("Scripting OK: %s" % scripting_ok)
+    print("SCRIPT_SUCCESS: Status check complete."); sys.exit(0)
+except Exception as e:
+    error_message = "Error during status check: %s" % e
+    print(error_message); print("Scripting OK: False")
+    # traceback.print_exc() # Optional traceback
+    print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)

package/src/scripts/compile_project.py

@@ -0,0 +1,65 @@
+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
+
+try:
+    print("DEBUG: compile_project script: Project='%s'" % PROJECT_FILE_PATH)
+    primary_project = ensure_project_open(PROJECT_FILE_PATH)
+    project_name = os.path.basename(PROJECT_FILE_PATH)
+    target_app = None
+    app_name = "N/A"
+
+    # Try getting active application first
+    try:
+        target_app = primary_project.active_application
+        if target_app:
+            app_name = getattr(target_app, 'get_name', lambda: "Unnamed App (Active)")()
+            print("DEBUG: Found active application: %s" % app_name)
+    except Exception as active_err:
+        print("WARN: Could not get active application: %s. Searching..." % active_err)
+
+    # If no active app, search for the first one
+    if not target_app:
+        print("DEBUG: Searching for first compilable application...")
+        apps = []
+        try:
+             # Search recursively through all project objects
+             all_children = primary_project.get_children(True)
+             for child in all_children:
+                  # Check using the marker property and if build method exists
+                  if hasattr(child, 'is_application') and child.is_application and hasattr(child, 'build'):
+                       app_name_found = getattr(child, 'get_name', lambda: "Unnamed App")()
+                       print("DEBUG: Found potential application object: %s" % app_name_found)
+                       apps.append(child)
+                       break # Take the first one found
+        except Exception as find_err: print("WARN: Error finding application object: %s" % find_err)
+
+        if not apps: raise RuntimeError("No compilable application found in project '%s'" % project_name)
+        target_app = apps[0]
+        app_name = getattr(target_app, 'get_name', lambda: "Unnamed App (First Found)")()
+        print("WARN: Compiling first found application: %s" % app_name)
+
+    print("DEBUG: Calling build() on app '%s'..." % app_name)
+    if not hasattr(target_app, 'build'):
+         raise TypeError("Selected object '%s' is not an application or doesn't support build()." % app_name)
+
+    # Execute the build
+    target_app.build();
+    print("DEBUG: Build command executed for application '%s'." % app_name)
+
+    # Check messages is harder without direct access to message store from script.
+    # Rely on CODESYS UI or log output for now.
+    print("Compile Initiated For Application: %s" % app_name)
+    print("In Project: %s" % project_name)
+    print("SCRIPT_SUCCESS: Application compilation initiated.")
+    sys.exit(0)
+except Exception as e:
+    detailed_error = traceback.format_exc()
+    error_message = "Error initiating compilation for project %s: %s\\n%s" % (PROJECT_FILE_PATH, e, detailed_error)
+    print(error_message)
+    print("SCRIPT_ERROR: %s" % error_message)
+    sys.exit(1)

package/src/scripts/create_method.py

@@ -0,0 +1,80 @@
+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"
+METHOD_NAME = "{METHOD_NAME}"
+RETURN_TYPE = "{RETURN_TYPE}" # Can be empty string for no return type
+# Optional: Language
+# LANG_GUID_STR = "{LANG_GUID_STR}" # Example if needed
+
+try:
+    print("DEBUG: create_method script: ParentPOU='%s', Name='%s', ReturnType='%s', Project='%s'" % (PARENT_POU_FULL_PATH, METHOD_NAME, RETURN_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 METHOD_NAME: raise ValueError("Method name empty.")
+    # RETURN_TYPE can be 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 methods (should implement ScriptIecLanguageMemberContainer)
+    if not hasattr(parent_pou_object, 'create_method'):
+         raise TypeError("Parent object '%s' of type %s does not support create_method." % (parent_pou_name, type(parent_pou_object).__name__))
+
+    # Default language to None (usually ST)
+    lang_guid = None
+    # Use None if RETURN_TYPE is empty string, otherwise use the string
+    actual_return_type = RETURN_TYPE if RETURN_TYPE else None
+    print("DEBUG: Calling create_method: Name='%s', ReturnType=%s, Lang=%s" % (METHOD_NAME, actual_return_type, lang_guid))
+
+    # Call the create_method method ON THE PARENT POU
+    new_method_object = parent_pou_object.create_method(
+        name=METHOD_NAME,
+        return_type=actual_return_type,
+        language=lang_guid # Pass None to use default
+    )
+
+    if new_method_object:
+        new_meth_name = getattr(new_method_object, 'get_name', lambda: METHOD_NAME)()
+        print("DEBUG: Method object created: %s" % new_meth_name)
+
+        # --- SAVE THE PROJECT TO PERSIST THE NEW METHOD OBJECT ---
+        try:
+            print("DEBUG: Saving Project (after method creation)...")
+            primary_project.save()
+            print("DEBUG: Project saved successfully after method creation.")
+        except Exception as save_err:
+            print("ERROR: Failed to save Project after creating method: %s" % save_err)
+            detailed_error = traceback.format_exc()
+            error_message = "Error saving Project after creating method '%s': %s\\n%s" % (METHOD_NAME, save_err, detailed_error)
+            print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)
+        # --- END SAVING ---
+
+        print("Method Created: %s" % new_meth_name)
+        print("Parent POU: %s" % PARENT_POU_FULL_PATH)
+        print("Return Type: %s" % (RETURN_TYPE if RETURN_TYPE else "(None)"))
+        print("SCRIPT_SUCCESS: Method created successfully.")
+        sys.exit(0)
+    else:
+         error_message = "Failed to create method '%s' under '%s'. create_method returned None." % (METHOD_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 method '%s' under POU '%s' in project '%s': %s\\n%s" % (METHOD_NAME, PARENT_POU_FULL_PATH, PROJECT_FILE_PATH, e, detailed_error)
+    print(error_message); print("SCRIPT_ERROR: %s" % error_message); sys.exit(1)