overhaul: character migrator integration

__init__.py

@@ -12,32 +12,36 @@
 # along with this program. If not, see <http://www.gnu.org/licenses/>.
 
 import bpy
-from bpy.props import StringProperty, BoolProperty, EnumProperty
-from bpy.types import Panel, Operator, PropertyGroup
 
-# Import local modules
+from .ui import CLASSES
-from . import operators
+from .ui.properties import DynamicLinkManagerProperties
-from . import ui
+from .ui.preferences import DynamicLinkManagerPreferences
+
 
 def ensure_default_search_path():
-    """Ensure there's always at least one search path"""
+    addon = bpy.context.preferences.addons.get(__name__)
-    prefs = bpy.context.preferences.addons.get(__name__)
+    if addon and len(addon.preferences.search_paths) == 0:
-    if prefs and len(prefs.preferences.search_paths) == 0:
+        addon.preferences.search_paths.add().path = "//"
-        new_path = prefs.preferences.search_paths.add()
+
-        new_path.path = "//"  # Default to relative path
 
 def register():
-    operators.register()
+    DynamicLinkManagerPreferences.bl_idname = __name__
-    ui.register()
+    for cls in CLASSES:
-    # Ensure default search path exists
+        bpy.utils.register_class(cls)
+    bpy.types.Scene.dynamic_link_manager = bpy.props.PointerProperty(type=DynamicLinkManagerProperties)
     bpy.app.handlers.load_post.append(ensure_default_search_path)
 
+
 def unregister():
-    ui.unregister()
-    operators.unregister()
-    # Remove the handler
     if ensure_default_search_path in bpy.app.handlers.load_post:
         bpy.app.handlers.load_post.remove(ensure_default_search_path)
+    del bpy.types.Scene.dynamic_link_manager
+    for cls in reversed(CLASSES):
+        try:
+            bpy.utils.unregister_class(cls)
+        except RuntimeError:
+            pass
+
 
 if __name__ == "__main__":
     register()

blender_manifest.toml

@@ -2,8 +2,8 @@ schema_version = "1.0.0"
 
 id = "dynamiclinkmanager"
 name = "Dynamic Link Manager"
-tagline = "Relink characters and library blends with ease"
+tagline = "Character migrator and linked library tools"
-version = "0.0.1"
+version = "0.0.2"
 type = "add-on"
 
 # Optional: Semantic Versioning

operators.py

@@ -1,728 +0,0 @@
-import bpy
-import os
-from bpy.types import Operator
-from bpy.props import StringProperty, BoolProperty, EnumProperty, IntProperty
-
-class DLM_OT_replace_linked_asset(Operator):
-    """Replace a linked asset with a new file"""
-    bl_idname = "dlm.replace_linked_asset"
-    bl_label = "Replace Linked Asset"
-    bl_options = {'REGISTER', 'UNDO'}
-    
-    filepath: StringProperty(
-        name="File Path",
-        description="Path to the new asset file",
-        subtype='FILE_PATH'
-    )
-    
-    def execute(self, context):
-        obj = context.active_object
-        if not obj:
-            self.report({'ERROR'}, "No object selected")
-            return {'CANCELLED'}
-        
-        # Comprehensive debug info
-        debug_info = f"Object: {obj.name}, Type: {obj.type}"
-        
-        # Check object library
-        if hasattr(obj, 'library'):
-            debug_info += f", Object has library attr: {obj.library is not None}"
-            if obj.library:
-                debug_info += f", Object library: {obj.library.filepath}"
-        
-        # Check object data
-        if obj.data:
-            debug_info += f", Has data: {type(obj.data).__name__}, Name: {obj.data.name}"
-            
-            # Check data library attribute
-            if hasattr(obj.data, 'library'):
-                debug_info += f", Data.library exists: {obj.data.library is not None}"
-                if obj.data.library:
-                    debug_info += f", Data.library.filepath: {obj.data.library.filepath}"
-            
-            # Check if data is in bpy.data collections
-            if obj.type == 'ARMATURE' and obj.data.name in bpy.data.armatures:
-                armature_data = bpy.data.armatures[obj.data.name]
-                debug_info += f", Found in bpy.data.armatures"
-                if hasattr(armature_data, 'library'):
-                    debug_info += f", bpy.data library: {armature_data.library is not None}"
-                    if armature_data.library:
-                        debug_info += f", bpy.data library path: {armature_data.library.filepath}"
-            
-            # Check if data is in bpy.data.objects
-            if obj.data.name in bpy.data.objects:
-                debug_info += f", Data also in bpy.data.objects"
-        
-        # Check if object itself is linked
-        if hasattr(obj, 'library') and obj.library:
-            self.report({'INFO'}, f"Object '{obj.name}' is linked from: {obj.library.filepath}")
-            return {'FINISHED'}
-        
-        # Check if object's data is linked
-        if obj.data and hasattr(obj.data, 'library') and obj.data.library:
-            self.report({'INFO'}, f"Object '{obj.name}' has linked data from: {obj.data.library.filepath}")
-            return {'FINISHED'}
-        
-        # Check if armature data is linked through bpy.data system
-        if obj.type == 'ARMATURE' and obj.data and obj.data.name in bpy.data.armatures:
-            armature_data = bpy.data.armatures[obj.data.name]
-            if hasattr(armature_data, 'library') and armature_data.library:
-                self.report({'INFO'}, f"Armature '{obj.name}' data is linked from: {armature_data.library.filepath}")
-                return {'FINISHED'}
-        
-        # If we get here, show debug info
-        self.report({'WARNING'}, debug_info)
-        self.report({'ERROR'}, "Selected object is not a linked asset")
-        return {'CANCELLED'}
-    
-    def invoke(self, context, event):
-        context.window_manager.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-
-class DLM_OT_scan_linked_assets(Operator):
-    """Scan scene for directly linked libraries and their status"""
-    bl_idname = "dlm.scan_linked_assets"
-    bl_label = "Scan Linked Libraries"
-    bl_options = {'REGISTER'}
-
-    def execute(self, context):
-        # Clear previous results
-        context.scene.dynamic_link_manager.linked_libraries.clear()
-        
-        # Function to check if file exists
-        def is_file_missing(filepath):
-            if not filepath:
-                return True
-            try:
-                abs_path = bpy.path.abspath(filepath)
-            except Exception:
-                abs_path = filepath
-            return not os.path.isfile(abs_path)
-        
-        # Function to get library name from path
-        def get_library_name(filepath):
-            if not filepath:
-                return "Unknown"
-            return os.path.basename(filepath)
-        
-        # Helper: naive scan of a .blend file to find referenced library paths
-        def scan_blend_for_missing_indirects(blend_path: str) -> bool:
-            """Return True if the .blend likely references at least one missing
-            library (.blend) path. This uses a conservative byte-string scan that
-            never loads data into Blender and is thus context-free and safe.
-
-            Strategy: look for substrings ending in .blend inside the file bytes
-            and expand left/right to the nearest NUL byte or line break to
-            reconstruct a plausible filesystem path. If any such path does not
-            exist on disk, we consider it an indirect missing dependency.
-            """
-            try:
-                if not blend_path or not os.path.exists(blend_path):
-                    return False
-                with open(blend_path, 'rb') as f:
-                    data = f.read()
-            except Exception:
-                return False
-
-            import re
-            base_dir = os.path.dirname(blend_path)
-            # Consider absolute Windows paths and Blender // relative paths
-            patterns = [
-                rb"[A-Za-z]:[\\/][^\r\n\0]*?\.blend",
-                rb"\\\\[^\r\n\0]*?\.blend",
-                rb"//[^\r\n\0]*?\.blend",
-            ]
-            for pat in patterns:
-                for m in re.finditer(pat, data):
-                    try:
-                        s = m.group(0).decode('utf-8', errors='ignore').strip().strip('"\'')
-                        if s.startswith('//'):
-                            rel = s[2:].replace('/', os.sep).replace('\\', os.sep)
-                            candidate = os.path.normpath(os.path.join(base_dir, rel))
-                        else:
-                            candidate = s
-                        if not os.path.isfile(candidate):
-                            return True
-                    except Exception:
-                        continue
-            return False
-
-        # Reload all libraries up front so Blender populates parent links
-        for lib in bpy.data.libraries:
-            try:
-                if lib.filepath:
-                    lib.reload()
-            except Exception:
-                pass
-
-        # Use Blender's library graph: direct libraries have no parent; indirect
-        # libraries have parent != None. We display only direct libraries.
-        direct_libs = set()
-        for lib in bpy.data.libraries:
-            try:
-                if lib.parent is None and lib.filepath:
-                    direct_libs.add(lib.filepath)
-            except Exception:
-                continue
-
-        # Only show directly used libraries in the main list
-        all_libraries = set(direct_libs)
-        
-        # Store results in scene properties
-        context.scene.dynamic_link_manager.linked_assets_count = len(all_libraries)
-        
-        # Build set of direct-parent libraries that have at least one missing
-        # indirect child, using the library.parent chain.
-        missing_indirect_libs = set()
-        for lib in bpy.data.libraries:
-            try:
-                if lib.parent is not None and lib.filepath:
-                    try:
-                        abs_child = bpy.path.abspath(lib.filepath)
-                    except Exception:
-                        abs_child = lib.filepath
-                    if not os.path.isfile(abs_child):
-                        # climb up to the root direct parent
-                        root = lib.parent
-                        while getattr(root, 'parent', None) is not None:
-                            root = root.parent
-                        if root and root.filepath:
-                            missing_indirect_libs.add(root.filepath)
-            except Exception:
-                continue
-
-        # Additionally, mark any direct library as INDIRECT if any of its
-        # linked ID users are flagged as missing by Blender (e.g., the source
-        # .blend no longer contains the datablock). This catches cases where
-        # the library file exists but its contents are missing.
-        missing_ids_by_library = set()
-        def check_missing_on(ids):
-            for idb in ids:
-                try:
-                    lib = getattr(idb, 'library', None)
-                    if lib and lib.filepath and getattr(idb, 'is_library_missing', False):
-                        missing_ids_by_library.add(lib.filepath)
-                except Exception:
-                    continue
-
-        check_missing_on(bpy.data.objects)
-        check_missing_on(bpy.data.meshes)
-        check_missing_on(bpy.data.armatures)
-        check_missing_on(bpy.data.materials)
-        check_missing_on(bpy.data.node_groups)
-        check_missing_on(bpy.data.images)
-        check_missing_on(bpy.data.texts)
-        check_missing_on(bpy.data.collections)
-        check_missing_on(bpy.data.cameras)
-        check_missing_on(bpy.data.lights)
-
-        # Create library items for the UI based on definitive indirect set
-        library_items = []
-        for filepath in sorted(all_libraries):
-            if not filepath:
-                continue
-            lib_item = context.scene.dynamic_link_manager.linked_libraries.add()
-            lib_item.filepath = filepath
-            lib_item.name = get_library_name(filepath)
-            lib_item.is_missing = is_file_missing(filepath)
-
-            # INDIRECT if it has a missing indirect child OR any linked IDs are missing
-            lib_item.is_indirect = (filepath in missing_indirect_libs) or (filepath in missing_ids_by_library)
-
-            # Store for sorting
-            library_items.append((lib_item, filepath))
-        
-        # Sort libraries: missing first, then by name
-        library_items.sort(key=lambda x: (not x[0].is_missing, get_library_name(x[1]).lower()))
-        
-        # Clear and re-add in sorted order
-        context.scene.dynamic_link_manager.linked_libraries.clear()
-        for lib_item, filepath in library_items:
-            new_item = context.scene.dynamic_link_manager.linked_libraries.add()
-            new_item.filepath = filepath
-            new_item.name = get_library_name(filepath)  # Use the function directly
-            new_item.is_missing = lib_item.is_missing
-            new_item.is_indirect = lib_item.is_indirect
-        
-        # Show detailed info
-        self.report({'INFO'}, f"Found {len(all_libraries)} unique linked library files")
-        if all_libraries:
-            for lib in sorted(all_libraries):
-                self.report({'INFO'}, f"Library: {lib}")
-        
-        return {'FINISHED'}
-
-class DLM_OT_find_libraries_in_folders(Operator):
-    """Find missing libraries in search folders and attempt to relocate them"""
-    bl_idname = "dlm.find_libraries_in_folders"
-    bl_label = "Find Libraries in Folders"
-    bl_options = {'REGISTER', 'UNDO'}
-    
-    def execute(self, context):
-        prefs = context.preferences.addons.get(__package__)
-        if not prefs or not prefs.preferences.search_paths:
-            self.report({'ERROR'}, "No search paths configured. Add search paths in addon preferences.")
-            return {'CANCELLED'}
-        
-        # Get missing libraries
-        missing_libs = [lib for lib in context.scene.dynamic_link_manager.linked_libraries if lib.is_missing]
-        if not missing_libs:
-            self.report({'INFO'}, "No missing libraries to find")
-            return {'FINISHED'}
-        
-        self.report({'INFO'}, f"Searching for {len(missing_libs)} missing libraries in search paths...")
-        
-        # Recursive directory scanning (searches all subfolders)
-        files_dir_list = []
-        total_dirs_scanned = 0
-        
-        try:
-            for search_path in prefs.preferences.search_paths:
-                if search_path.path:
-                    # Handle both relative and absolute paths
-                    if search_path.path.startswith("//"):
-                        # Relative path - convert to absolute
-                        abs_path = bpy.path.abspath(search_path.path)
-                    else:
-                        # Absolute path - use as is
-                        abs_path = search_path.path
-                    
-                    self.report({'INFO'}, f"Scanning search path: {abs_path}")
-                    
-                    # Check if path exists and is accessible
-                    if not os.path.exists(abs_path):
-                        self.report({'WARNING'}, f"Search path does not exist or is not accessible: {abs_path}")
-                        continue
-                    
-                    if not os.path.isdir(abs_path):
-                        self.report({'WARNING'}, f"Search path is not a directory: {abs_path}")
-                        continue
-                    
-                    # Use os.walk to recursively scan all subdirectories
-                    for dirpath, dirnames, filenames in os.walk(abs_path):
-                        files_dir_list.append([dirpath, filenames])
-                        total_dirs_scanned += 1
-                        
-                        # Debug: Show what we're finding
-                        if len(filenames) > 0:
-                            blend_files = [f for f in filenames if f.endswith('.blend')]
-                            if blend_files:
-                                self.report({'INFO'}, f"  Found {len(blend_files)} .blend files in: {dirpath}")
-                        
-                        # Limit to prevent excessive scanning (safety measure)
-                        if total_dirs_scanned > 1000:
-                            self.report({'WARNING'}, "Reached scan limit of 1000 directories. Some subfolders may not be scanned.")
-                            break
-                    
-                    self.report({'INFO'}, f"Scanned {total_dirs_scanned} directories from search path: {abs_path}")
-                    
-        except FileNotFoundError as e:
-            self.report({'ERROR'}, f"Error - Bad file path in search paths: {e}")
-            return {'CANCELLED'}
-        except Exception as e:
-            self.report({'ERROR'}, f"Error scanning search paths: {e}")
-            return {'CANCELLED'}
-        
-        self.report({'INFO'}, f"Total directories scanned: {total_dirs_scanned}")
-        
-        # Phase 1: Library finding with recursive search
-        found_libraries = {}  # Dictionary to store filename -> full path mapping
-        found_count = 0
-        
-        self.report({'INFO'}, "=== PHASE 1: SEARCHING FOR LIBRARIES ===")
-        
-        for lib_item in missing_libs:
-            lib_filename = os.path.basename(lib_item.filepath)
-            self.report({'INFO'}, f"Looking for: {lib_filename}")
-            
-            for dir_info in files_dir_list:
-                dirpath, filenames = dir_info
-                
-                # Exact filename match
-                if lib_filename in filenames:
-                    new_path = os.path.join(dirpath, lib_filename)
-                    found_libraries[lib_filename] = new_path
-                    self.report({'INFO'}, f"✓ Found {lib_filename} at: {new_path}")
-                    found_count += 1
-                    break
-        
-        self.report({'INFO'}, f"=== SEARCH COMPLETE: Found {found_count} out of {len(missing_libs)} missing libraries ===")
-        
-        # Phase 2: Relinking found libraries
-        if found_count > 0:
-            self.report({'INFO'}, "=== PHASE 2: RELINKING LIBRARIES ===")
-            
-            # Manual, deterministic relink of exact filename matches.
-            relinked_count = 0
-            for lib in bpy.data.libraries:
-                try:
-                    if not lib.filepath:
-                        continue
-                    lib_filename = os.path.basename(lib.filepath)
-                    if lib_filename in found_libraries:
-                        new_path = found_libraries[lib_filename]
-                        # Only update if currently missing and different
-                        current_abs = bpy.path.abspath(lib.filepath)
-                        if (not os.path.isfile(current_abs)) or (current_abs != new_path):
-                            lib.filepath = new_path
-                            try:
-                                lib.reload()
-                            except Exception:
-                                pass
-                            relinked_count += 1
-                            self.report({'INFO'}, f"Relinked {lib_filename} -> {new_path}")
-                except Exception:
-                    continue
-
-            if relinked_count == 0:
-                self.report({'WARNING'}, "No libraries were relinked; ensure filenames match exactly in search paths.")
-            else:
-                self.report({'INFO'}, f"✓ Manually relinked {relinked_count} libraries")
-        else:
-            self.report({'WARNING'}, "No libraries found in search paths - nothing to relink")
-        
-        # Trigger a rescan so UI reflects current status immediately
-        try:
-            bpy.ops.dlm.scan_linked_assets()
-        except Exception:
-            pass
-        self.report({'INFO'}, "=== OPERATION COMPLETE ===")
-        return {'FINISHED'}
-
-def register():
-    bpy.utils.register_class(DLM_OT_replace_linked_asset)
-    bpy.utils.register_class(DLM_OT_scan_linked_assets)
-
-class DLM_OT_open_linked_file(Operator):
-    """Open the linked file in a new Blender instance"""
-    bl_idname = "dlm.open_linked_file"
-    bl_label = "Open Linked File"
-    bl_options = {'REGISTER'}
-    
-    filepath: StringProperty(
-        name="File Path",
-        description="Path to the linked file",
-        default=""
-    )
-    
-    def execute(self, context):
-        if not self.filepath:
-            self.report({'ERROR'}, "No file path specified")
-            return {'CANCELLED'}
-        
-        # Try to open the linked file in a new Blender instance
-        try:
-            # Use Blender's built-in file browser to open the file
-            bpy.ops.wm.path_open(filepath=self.filepath)
-            self.report({'INFO'}, f"Opening linked file: {self.filepath}")
-        except Exception as e:
-            self.report({'ERROR'}, f"Failed to open linked file: {e}")
-            return {'CANCELLED'}
-        
-        return {'FINISHED'}
-
-class DLM_OT_add_search_path(Operator):
-    """Add a new search path for missing libraries"""
-    bl_idname = "dlm.add_search_path"
-    bl_label = "Add Search Path"
-    bl_options = {'REGISTER'}
-    
-    def execute(self, context):
-        prefs = context.preferences.addons.get(__package__)
-        if prefs:
-            new_path = prefs.preferences.search_paths.add()
-            new_path.path = "//"  # Default to relative path
-            self.report({'INFO'}, f"Added search path: {new_path.path}")
-        return {'FINISHED'}
-
-class DLM_OT_remove_search_path(Operator):
-    """Remove a search path"""
-    bl_idname = "dlm.remove_search_path"
-    bl_label = "Remove Search Path"
-    bl_options = {'REGISTER'}
-    
-    index: IntProperty(
-        name="Index",
-        description="Index of the search path to remove",
-        default=0
-    )
-    
-    def execute(self, context):
-        prefs = context.preferences.addons.get(__package__)
-        if prefs and prefs.preferences.search_paths:
-            if 0 <= self.index < len(prefs.preferences.search_paths):
-                prefs.preferences.search_paths.remove(self.index)
-                self.report({'INFO'}, f"Removed search path at index {self.index}")
-            else:
-                self.report({'ERROR'}, f"Invalid index: {self.index}")
-        return {'FINISHED'}
-
-class DLM_OT_attempt_relink(Operator):
-    """Attempt to relink missing libraries using search paths"""
-    bl_idname = "dlm.attempt_relink"
-    bl_label = "Attempt Relink"
-    bl_options = {'REGISTER'}
-    
-    def execute(self, context):
-        prefs = context.preferences.addons.get(__package__)
-        if not prefs or not prefs.preferences.search_paths:
-            self.report({'ERROR'}, "No search paths configured. Add search paths in addon preferences.")
-            return {'CANCELLED'}
-        
-        # Get missing libraries
-        missing_libs = [lib for lib in context.scene.dynamic_link_manager.linked_libraries if lib.is_missing]
-        if not missing_libs:
-            self.report({'INFO'}, "No missing libraries to relink")
-            return {'FINISHED'}
-        
-        self.report({'INFO'}, f"Attempting to relink {len(missing_libs)} missing libraries...")
-        
-        # Scan search paths for missing libraries (FMT-inspired approach)
-        files_dir_list = []
-        try:
-            for search_path in prefs.preferences.search_paths:
-                if search_path.path:
-                    for dirpath, dirnames, filenames in os.walk(bpy.path.abspath(search_path.path)):
-                        files_dir_list.append([dirpath, filenames])
-        except FileNotFoundError:
-            self.report({'ERROR'}, f"Error - Bad file path in search paths")
-            return {'CANCELLED'}
-        
-        # Try to find and relink each missing library
-        relinked_count = 0
-        indirect_errors = []
-        
-        for lib_item in missing_libs:
-            lib_filename = os.path.basename(lib_item.filepath)
-            found = False
-            
-            # Search through all directories
-            for dir_info in files_dir_list:
-                dirpath, filenames = dir_info
-                
-                # Look for exact filename match
-                if lib_filename in filenames:
-                    new_path = os.path.join(dirpath, lib_filename)
-                    try:
-                        # Try to relink using Blender's system
-                        # This will naturally detect indirect links if they exist
-                        bpy.ops.file.find_missing_files()
-                        found = True
-                        relinked_count += 1
-                        break
-                    except Exception as e:
-                        error_msg = str(e)
-                        if "unable to relocate indirectly linked library" in error_msg:
-                            indirect_errors.append(lib_item.filepath)
-                            print(f"Indirect link detected for: {lib_item.filepath}")
-                        else:
-                            print(f"Error relinking {lib_item.filepath}: {e}")
-                
-                if found:
-                    break
-            
-            if not found:
-                print(f"Could not find {lib_filename} in search paths")
-        
-        # Update the UI to show indirect links
-        if indirect_errors:
-            self.report({'WARNING'}, f"Found {len(indirect_errors)} indirectly linked libraries")
-            # Mark these as having indirect missing
-            for lib_item in context.scene.dynamic_link_manager.linked_libraries:
-                if lib_item.filepath in indirect_errors:
-                    lib_item.has_indirect_missing = True
-                    lib_item.indirect_missing_count = 1
-        
-        self.report({'INFO'}, f"Relink attempt complete. Relinked: {relinked_count}, Indirect: {len(indirect_errors)}")
-        return {'FINISHED'}
-
-
-
-class DLM_OT_browse_search_path(Operator):
-    """Browse for a search path directory"""
-    bl_idname = "dlm.browse_search_path"
-    bl_label = "Browse Search Path"
-    bl_options = {'REGISTER'}
-    
-    index: IntProperty(
-        name="Index",
-        description="Index of the search path to browse for",
-        default=0
-    )
-    
-    filepath: StringProperty(
-        name="Search Path",
-        description="Path to search for missing linked libraries",
-        subtype='DIR_PATH'
-    )
-    
-    def execute(self, context):
-        prefs = context.preferences.addons.get(__package__)
-        if prefs and prefs.preferences.search_paths:
-            if 0 <= self.index < len(prefs.preferences.search_paths):
-                prefs.preferences.search_paths[self.index].path = self.filepath
-                self.report({'INFO'}, f"Updated search path {self.index + 1}: {self.filepath}")
-            else:
-                self.report({'ERROR'}, f"Invalid index: {self.index}")
-        return {'FINISHED'}
-    
-    def invoke(self, context, event):
-        prefs = context.preferences.addons.get(__package__)
-        if prefs and prefs.preferences.search_paths:
-            if 0 <= self.index < len(prefs.preferences.search_paths):
-                # Set the current path as default
-                self.filepath = prefs.preferences.search_paths[self.index].path
-        context.window_manager.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-
-
-
-class DLM_OT_reload_libraries(Operator):
-    """Reload all libraries using Blender's built-in reload operation"""
-    bl_idname = "dlm.reload_libraries"
-    bl_label = "Reload Libraries"
-    bl_options = {'REGISTER'}
-    
-    def execute(self, context):
-        try:
-            # Try the outliner operation first
-            bpy.ops.outliner.lib_operation(type='RELOAD')
-            self.report({'INFO'}, "Library reload operation completed")
-        except Exception as e:
-            # Fallback: manually reload libraries
-            try:
-                for library in bpy.data.libraries:
-                    if library.filepath and os.path.exists(bpy.path.abspath(library.filepath)):
-                        library.reload()
-                self.report({'INFO'}, "Libraries reloaded manually")
-            except Exception as e2:
-                self.report({'ERROR'}, f"Failed to reload libraries: {e2}")
-                return {'CANCELLED'}
-        return {'FINISHED'}
-
-class DLM_OT_make_paths_relative(Operator):
-    """Make all file paths in the scene relative"""
-    bl_idname = "dlm.make_paths_relative"
-    bl_label = "Make Paths Relative"
-    bl_options = {'REGISTER'}
-    
-    def execute(self, context):
-        try:
-            # Use Blender's built-in operator to make paths relative
-            bpy.ops.file.make_paths_relative()
-            self.report({'INFO'}, "All file paths made relative")
-        except Exception as e:
-            self.report({'ERROR'}, f"Failed to make paths relative: {e}")
-            return {'CANCELLED'}
-        return {'FINISHED'}
-
-class DLM_OT_make_paths_absolute(Operator):
-    """Make all file paths in the scene absolute"""
-    bl_idname = "dlm.make_paths_absolute"
-    bl_label = "Make Paths Absolute"
-    bl_options = {'REGISTER'}
-    
-    def execute(self, context):
-        try:
-            # Use Blender's built-in operator to make paths absolute
-            bpy.ops.file.make_paths_absolute()
-            self.report({'INFO'}, "All file paths made absolute")
-        except Exception as e:
-            self.report({'ERROR'}, f"Failed to make paths absolute: {e}")
-            return {'CANCELLED'}
-        return {'FINISHED'}
-
-class DLM_OT_relocate_single_library(Operator):
-    """Relocate a single library by choosing a new .blend and reloading it (context-free)"""
-    bl_idname = "dlm.relocate_single_library"
-    bl_label = "Relocate Library"
-    bl_options = {'REGISTER', 'UNDO'}
-
-    # The library we want to relocate (current path as stored on the item)
-    target_filepath: StringProperty(
-        name="Current Library Path",
-        description="Current path of the library to relocate",
-        default=""
-    )
-
-    # New file chosen by the user via file selector
-    filepath: StringProperty(
-        name="New Library File",
-        description="Choose the new .blend file for this library",
-        subtype='FILE_PATH',
-        default=""
-    )
-
-    def _find_library_by_path(self, path_to_match: str):
-        abs_match = bpy.path.abspath(path_to_match) if path_to_match else ""
-        for lib in bpy.data.libraries:
-            try:
-                if bpy.path.abspath(lib.filepath) == abs_match:
-                    return lib
-            except Exception:
-                # In case abspath fails for odd paths
-                if lib.filepath == path_to_match:
-                    return lib
-        return None
-
-    def execute(self, context):
-        if not self.target_filepath:
-            self.report({'ERROR'}, "No target library specified")
-            return {'CANCELLED'}
-        if not self.filepath:
-            self.report({'ERROR'}, "No new file selected")
-            return {'CANCELLED'}
-
-        library = self._find_library_by_path(self.target_filepath)
-        if not library:
-            self.report({'ERROR'}, "Could not resolve the selected library in bpy.data.libraries")
-            return {'CANCELLED'}
-
-        try:
-            # Assign the new path and reload the library datablocks
-            library.filepath = self.filepath
-            library.reload()
-            self.report({'INFO'}, f"Relocated to: {self.filepath}")
-        except Exception as e:
-            self.report({'ERROR'}, f"Failed to relocate: {e}")
-            return {'CANCELLED'}
-
-        return {'FINISHED'}
-
-    def invoke(self, context, event):
-        # Pre-populate the selector with the current path when possible
-        if self.target_filepath:
-            try:
-                self.filepath = bpy.path.abspath(self.target_filepath)
-            except Exception:
-                self.filepath = self.target_filepath
-        context.window_manager.fileselect_add(self)
-        return {'RUNNING_MODAL'}
-
-def register():
-    bpy.utils.register_class(DLM_OT_replace_linked_asset)
-    bpy.utils.register_class(DLM_OT_scan_linked_assets)
-    bpy.utils.register_class(DLM_OT_open_linked_file)
-    bpy.utils.register_class(DLM_OT_add_search_path)
-    bpy.utils.register_class(DLM_OT_remove_search_path)
-    bpy.utils.register_class(DLM_OT_browse_search_path)
-    bpy.utils.register_class(DLM_OT_attempt_relink)
-    bpy.utils.register_class(DLM_OT_find_libraries_in_folders)
-    bpy.utils.register_class(DLM_OT_reload_libraries)
-    bpy.utils.register_class(DLM_OT_make_paths_relative)
-    bpy.utils.register_class(DLM_OT_make_paths_absolute)
-    bpy.utils.register_class(DLM_OT_relocate_single_library)
-
-def unregister():
-    bpy.utils.unregister_class(DLM_OT_find_libraries_in_folders)
-    bpy.utils.unregister_class(DLM_OT_attempt_relink)
-    bpy.utils.unregister_class(DLM_OT_browse_search_path)
-    bpy.utils.unregister_class(DLM_OT_remove_search_path)
-    bpy.utils.unregister_class(DLM_OT_add_search_path)
-    bpy.utils.unregister_class(DLM_OT_open_linked_file)
-    bpy.utils.unregister_class(DLM_OT_scan_linked_assets)
-    bpy.utils.unregister_class(DLM_OT_replace_linked_asset)
-    bpy.utils.unregister_class(DLM_OT_reload_libraries)
-    bpy.utils.unregister_class(DLM_OT_make_paths_relative)
-    bpy.utils.unregister_class(DLM_OT_make_paths_absolute)
-    bpy.utils.unregister_class(DLM_OT_relocate_single_library)

ops/__init__.py

@@ -0,0 +1,6 @@
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+"""Feature logic (migrator, library) for Dynamic Link Manager."""

ops/library.py

@@ -0,0 +1,207 @@
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+import os
+import re
+import bpy
+
+
+def _is_file_missing(filepath):
+    if not filepath:
+        return True
+    try:
+        abs_path = bpy.path.abspath(filepath)
+    except Exception:
+        abs_path = filepath
+    return not os.path.isfile(abs_path)
+
+
+def _get_library_name(filepath):
+    return os.path.basename(filepath) if filepath else "Unknown"
+
+
+def scan_linked_assets(context, report):
+    props = context.scene.dynamic_link_manager
+    props.linked_libraries.clear()
+
+    for lib in bpy.data.libraries:
+        try:
+            if lib.filepath:
+                lib.reload()
+        except Exception:
+            pass
+
+    direct_libs = set()
+    for lib in bpy.data.libraries:
+        try:
+            if getattr(lib, "parent", None) is None and lib.filepath:
+                direct_libs.add(lib.filepath)
+        except Exception:
+            continue
+    all_libraries = set(direct_libs)
+    props.linked_assets_count = len(all_libraries)
+
+    missing_indirect_libs = set()
+    for lib in bpy.data.libraries:
+        try:
+            if getattr(lib, "parent", None) is not None and lib.filepath:
+                try:
+                    abs_child = bpy.path.abspath(lib.filepath)
+                except Exception:
+                    abs_child = lib.filepath
+                if not os.path.isfile(abs_child):
+                    root = lib.parent
+                    while getattr(root, "parent", None) is not None:
+                        root = root.parent
+                    if root and root.filepath:
+                        missing_indirect_libs.add(root.filepath)
+        except Exception:
+            continue
+
+    missing_ids_by_library = set()
+    for idb in list(bpy.data.objects) + list(bpy.data.meshes) + list(bpy.data.armatures) + list(bpy.data.materials) + list(bpy.data.node_groups) + list(bpy.data.images) + list(bpy.data.texts) + list(bpy.data.collections) + list(bpy.data.cameras) + list(bpy.data.lights):
+        try:
+            lib = getattr(idb, "library", None)
+            if lib and lib.filepath and getattr(idb, "is_library_missing", False):
+                missing_ids_by_library.add(lib.filepath)
+        except Exception:
+            continue
+
+    library_items = []
+    for filepath in sorted(all_libraries):
+        if not filepath:
+            continue
+        lib_item = props.linked_libraries.add()
+        lib_item.filepath = filepath
+        lib_item.name = _get_library_name(filepath)
+        lib_item.is_missing = _is_file_missing(filepath)
+        lib_item.is_indirect = (filepath in missing_indirect_libs) or (filepath in missing_ids_by_library)
+        library_items.append((lib_item, filepath))
+
+    library_items.sort(key=lambda x: (not x[0].is_missing, _get_library_name(x[1]).lower()))
+    props.linked_libraries.clear()
+    for lib_item, filepath in library_items:
+        new_item = props.linked_libraries.add()
+        new_item.filepath = filepath
+        new_item.name = _get_library_name(filepath)
+        new_item.is_missing = lib_item.is_missing
+        new_item.is_indirect = lib_item.is_indirect
+
+    report({"INFO"}, f"Found {len(all_libraries)} unique linked library files")
+    return {"FINISHED"}
+
+
+def find_libraries_in_folders(context, report, addon_name=None):
+    if addon_name is None:
+        addon_name = __package__.rsplit(".", 1)[0] if "." in __package__ else __package__
+    prefs = context.preferences.addons.get(addon_name)
+    if not prefs or not prefs.preferences.search_paths:
+        report({"ERROR"}, "No search paths configured. Add search paths in addon preferences.")
+        return {"CANCELLED"}
+
+    missing_libs = [lib for lib in context.scene.dynamic_link_manager.linked_libraries if lib.is_missing]
+    if not missing_libs:
+        report({"INFO"}, "No missing libraries to find")
+        return {"FINISHED"}
+
+    report({"INFO"}, f"Searching for {len(missing_libs)} missing libraries in search paths...")
+    files_dir_list = []
+    total_dirs_scanned = 0
+    try:
+        for search_path in prefs.preferences.search_paths:
+            if not search_path.path:
+                continue
+            abs_path = bpy.path.abspath(search_path.path) if search_path.path.startswith("//") else search_path.path
+            report({"INFO"}, f"Scanning search path: {abs_path}")
+            if not os.path.exists(abs_path):
+                report({"WARNING"}, f"Search path does not exist: {abs_path}")
+                continue
+            if not os.path.isdir(abs_path):
+                report({"WARNING"}, f"Search path is not a directory: {abs_path}")
+                continue
+            for dirpath, dirnames, filenames in os.walk(abs_path):
+                files_dir_list.append([dirpath, filenames])
+                total_dirs_scanned += 1
+                if total_dirs_scanned > 1000:
+                    report({"WARNING"}, "Reached scan limit of 1000 directories.")
+                    break
+    except Exception as e:
+        report({"ERROR"}, f"Error scanning search paths: {e}")
+        return {"CANCELLED"}
+
+    found_libraries = {}
+    for lib_item in missing_libs:
+        lib_filename = os.path.basename(lib_item.filepath)
+        for dirpath, filenames in files_dir_list:
+            if lib_filename in filenames:
+                found_libraries[lib_filename] = os.path.join(dirpath, lib_filename)
+                report({"INFO"}, f"Found {lib_filename} at: {os.path.join(dirpath, lib_filename)}")
+                break
+
+    if found_libraries:
+        relinked_count = 0
+        for lib in bpy.data.libraries:
+            try:
+                if not lib.filepath:
+                    continue
+                lib_filename = os.path.basename(lib.filepath)
+                if lib_filename in found_libraries:
+                    new_path = found_libraries[lib_filename]
+                    current_abs = bpy.path.abspath(lib.filepath)
+                    if not os.path.isfile(current_abs) or current_abs != new_path:
+                        lib.filepath = new_path
+                        try:
+                            lib.reload()
+                        except Exception:
+                            pass
+                        relinked_count += 1
+                        report({"INFO"}, f"Relinked {lib_filename} -> {new_path}")
+            except Exception:
+                continue
+        report({"INFO"}, f"Manually relinked {relinked_count} libraries")
+    else:
+        report({"WARNING"}, "No libraries found in search paths")
+    try:
+        bpy.ops.dlm.scan_linked_assets()
+    except Exception:
+        pass
+    report({"INFO"}, "Operation complete.")
+    return {"FINISHED"}
+
+
+def attempt_relink(context, report, addon_name=None):
+    if addon_name is None:
+        addon_name = __package__.rsplit(".", 1)[0] if "." in __package__ else __package__
+    prefs = context.preferences.addons.get(addon_name)
+    if not prefs or not prefs.preferences.search_paths:
+        report({"ERROR"}, "No search paths configured.")
+        return {"CANCELLED"}
+    missing_libs = [lib for lib in context.scene.dynamic_link_manager.linked_libraries if lib.is_missing]
+    if not missing_libs:
+        report({"INFO"}, "No missing libraries to relink")
+        return {"FINISHED"}
+    report({"INFO"}, f"Attempting to relink {len(missing_libs)} missing libraries...")
+    files_dir_list = []
+    try:
+        for search_path in prefs.preferences.search_paths:
+            if search_path.path:
+                for dirpath, dirnames, filenames in os.walk(bpy.path.abspath(search_path.path)):
+                    files_dir_list.append([dirpath, filenames])
+    except FileNotFoundError:
+        report({"ERROR"}, "Bad file path in search paths")
+        return {"CANCELLED"}
+    relinked_count = 0
+    for lib_item in missing_libs:
+        lib_filename = os.path.basename(lib_item.filepath)
+        for dirpath, filenames in files_dir_list:
+            if lib_filename in filenames:
+                try:
+                    bpy.ops.file.find_missing_files()
+                    relinked_count += 1
+                except Exception:
+                    pass
+                break
+    report({"INFO"}, f"Relink attempt complete. Relinked: {relinked_count}")
+    return {"FINISHED"}

ops/migrator.py

@@ -0,0 +1,211 @@
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+"""Character migrator: migrate animation, constraints, relations from original to replacement armature."""
+
+import bpy
+
+from ..utils import descendants
+
+
+def get_pair_manual(context):
+    """Return (orig_armature, rep_armature) from scene props, or (None, None)."""
+    props = getattr(context.scene, "dynamic_link_manager", None)
+    if not props:
+        return None, None
+    orig = getattr(props, "original_character", None)
+    rep = getattr(props, "replacement_character", None)
+    if orig and orig.type == "ARMATURE" and rep and rep.type == "ARMATURE":
+        return orig, rep
+    return None, None
+
+
+def get_pair_automatic(context):
+    """Discover one pair by convention: Name_Rigify and Name_Rigify.001. Returns (orig, rep) or (None, None)."""
+    pairs = []
+    for obj in bpy.data.objects:
+        if obj.type != "ARMATURE":
+            continue
+        name = obj.name
+        if name.endswith("_Rigify.001"):
+            base = name[:-len("_Rigify.001")]
+            orig = bpy.data.objects.get(f"{base}_Rigify")
+            if orig and orig.type == "ARMATURE" and orig != obj:
+                pairs.append((orig, obj))
+    return pairs[0] if pairs else (None, None)
+
+
+def run_step_1(orig, rep):
+    """Copy armature object attributes: location, rotation, scale."""
+    rep.location = orig.location.copy()
+    if orig.rotation_mode == "QUATERNION":
+        rep.rotation_quaternion = orig.rotation_quaternion.copy()
+    else:
+        rep.rotation_euler = orig.rotation_euler.copy()
+    rep.scale = orig.scale.copy()
+
+
+def run_step_2(orig, rep):
+    """Migrate NLA: copy tracks and strips to replacement."""
+    if not orig.animation_data or not orig.animation_data.nla_tracks:
+        return
+    if rep.animation_data is None:
+        rep.animation_data_create()
+    for track in list(rep.animation_data.nla_tracks):
+        rep.animation_data.nla_tracks.remove(track)
+    prev_track = None
+    for track in orig.animation_data.nla_tracks:
+        new_track = rep.animation_data.nla_tracks.new(prev=prev_track)
+        new_track.name = track.name
+        new_track.mute = track.mute
+        new_track.is_solo = track.is_solo
+        new_track.lock = track.lock
+        for strip in track.strips:
+            new_strip = new_track.strips.new(strip.name, int(strip.frame_start), strip.action)
+            new_strip.blend_type = strip.blend_type
+            new_strip.extrapolation = strip.extrapolation
+            new_strip.frame_end = strip.frame_end
+            new_strip.blend_in = strip.blend_in
+            new_strip.blend_out = strip.blend_out
+            new_strip.repeat = strip.repeat
+        prev_track = new_track
+
+
+EXCLUDE_PROPS = {"_RNA_UI", "rigify_type", "rigify_parameters"}
+
+
+def run_step_3(orig, rep):
+    """Custom properties: copy pose-bone custom props, exclude rigify internals."""
+    for pbone in orig.pose.bones:
+        if pbone.name not in rep.pose.bones:
+            continue
+        rbone = rep.pose.bones[pbone.name]
+        for key in list(pbone.keys()):
+            if key in EXCLUDE_PROPS:
+                continue
+            try:
+                rbone[key] = pbone[key]
+            except Exception:
+                pass
+
+
+def run_step_4(orig, rep, orig_to_rep):
+    """Bone constraints: remove stale on rep, copy from orig with retarget, trim duplicates."""
+    other_originals = [o for o in orig_to_rep if o != orig]
+    for pb in rep.pose.bones:
+        to_remove = [c for c in pb.constraints if getattr(c, "target", None) in other_originals]
+        for c in to_remove:
+            pb.constraints.remove(c)
+    for pbone in orig.pose.bones:
+        if pbone.name not in rep.pose.bones:
+            continue
+        rbone = rep.pose.bones[pbone.name]
+        for c in pbone.constraints:
+            if getattr(c, "target", None) == orig:
+                continue
+            nc = rbone.constraints.new(type=c.type)
+            nc.name = c.name
+            nc.mute = c.mute
+            nc.influence = c.influence
+            t = getattr(c, "target", None)
+            if t is not None and t in orig_to_rep:
+                nc.target = orig_to_rep[t]
+            elif getattr(nc, "target", None) is not None and t:
+                nc.target = t
+            if hasattr(c, "subtarget") and c.subtarget:
+                nc.subtarget = c.subtarget
+            for prop in ("head_tail", "use_bone_object", "invert_x", "invert_y", "invert_z"):
+                if hasattr(c, prop):
+                    try:
+                        setattr(nc, prop, getattr(c, prop))
+                    except Exception:
+                        pass
+    for pb in orig.pose.bones:
+        if pb.name not in rep.pose.bones:
+            continue
+        ro, rr = pb.constraints, rep.pose.bones[pb.name].constraints
+        while len(rr) > len(ro):
+            rr.remove(rr[-1])
+
+
+def run_step_5(orig, rep, rep_descendants, orig_to_rep):
+    """Retarget relations: parents, constraint targets, Armature modifiers to rep."""
+    candidates = set(rep_descendants)
+    for ob in bpy.data.objects:
+        if getattr(ob.parent, "name", None) == orig.name:
+            candidates.add(ob)
+        for c in getattr(ob, "constraints", []):
+            if getattr(c, "target", None) == orig:
+                candidates.add(ob)
+    for ob in candidates:
+        if ob.parent == orig:
+            ob.parent = rep
+        for c in getattr(ob, "constraints", []):
+            if getattr(c, "target", None) == orig:
+                c.target = rep
+        if ob.type == "MESH" and ob.modifiers:
+            for m in ob.modifiers:
+                if getattr(m, "object", None) == orig:
+                    m.object = rep
+
+
+def run_step_6(orig, rep, rep_descendants):
+    """Replacement base body: library override only, then shape-key action."""
+    for ob in rep_descendants:
+        if ob.type != "MESH":
+            continue
+        name_lower = (ob.name + " " + (ob.data.name if ob.data else "")).lower()
+        if "body" not in name_lower or "base" not in name_lower:
+            continue
+        if ob.modifiers:
+            for m in ob.modifiers:
+                if m.type == "ARMATURE" and m.object == rep:
+                    break
+            else:
+                continue
+        if getattr(ob.data, "library", None) or getattr(ob.data, "override_library", None):
+            try:
+                ob.data.override_create()
+            except Exception:
+                pass
+        if ob.data.shape_keys:
+            if not ob.data.shape_keys.animation_data:
+                ob.data.shape_keys.animation_data_create()
+            body_name = ob.name
+            action = (
+                bpy.data.actions.get(body_name + "Action")
+                or bpy.data.actions.get(ob.data.name + "Action")
+                or bpy.data.actions.get(body_name + "Action.001")
+            )
+            if action:
+                ob.data.shape_keys.animation_data.action = action
+
+
+def run_full_migration(context):
+    """
+    Run the full 7-step character migration for the single pair (manual or automatic).
+    Returns (True, message) on success, (False, error_message) on failure.
+    """
+    props = getattr(context.scene, "dynamic_link_manager", None)
+    use_auto = props and getattr(props, "migrator_mode", False)
+    orig, rep = (get_pair_automatic(context) if use_auto else get_pair_manual(context))
+    if not orig or not rep:
+        return False, "No character pair (set Original/Replacement or enable Automatic)."
+    if orig == rep:
+        return False, "Original and replacement must be different armatures."
+
+    orig_to_rep = {orig: rep}
+    rep_descendants = descendants(rep)
+
+    try:
+        run_step_1(orig, rep)
+        run_step_2(orig, rep)
+        run_step_3(orig, rep)
+        run_step_4(orig, rep, orig_to_rep)
+        run_step_5(orig, rep, rep_descendants, orig_to_rep)
+        run_step_6(orig, rep, rep_descendants)
+    except Exception as e:
+        return False, str(e)
+    return True, f"Migrated {orig.name} → {rep.name}"

ui.py

@@ -1,294 +0,0 @@
-import bpy
-from bpy.types import Panel, PropertyGroup, AddonPreferences, UIList
-from bpy.props import IntProperty, StringProperty, BoolProperty, CollectionProperty
-
-# Properties for search paths
-class SearchPathItem(PropertyGroup):
-    path: StringProperty(
-        name="Search Path",
-        description="Path to search for missing linked libraries",
-        subtype='DIR_PATH'
-    )
-
-# Properties for individual linked datablocks
-class LinkedDatablockItem(PropertyGroup):
-    name: StringProperty(name="Name", description="Name of the linked datablock")
-    type: StringProperty(name="Type", description="Type of the linked datablock")
-
-# UIList for linked libraries
-class DLM_UL_library_list(UIList):
-    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
-        custom_icon = 'FILE_BLEND'
-        
-        if self.layout_type in {'DEFAULT', 'COMPACT'}:
-            # Library name and status
-            layout.scale_x = 0.4
-            layout.label(text=item.name)
-            
-            # Status indicator
-            layout.scale_x = 0.3
-            if item.is_missing:
-                layout.label(text="MISSING", icon='ERROR')
-            elif item.is_indirect:
-                layout.label(text="INDIRECT", icon='INFO')
-            else:
-                layout.label(text="OK", icon='FILE_BLEND')
-            
-            # File path (abbreviated)
-            layout.scale_x = 0.3
-            path_text = item.filepath
-            if path_text.startswith("\\\\"):
-                # Network path: show server name
-                parts = path_text.split("\\")
-                if len(parts) >= 3:
-                    short_path = f"\\\\{parts[2]}\\"
-                else:
-                    short_path = "\\\\ (network)"
-            elif len(path_text) >= 2 and path_text[1] == ':':
-                # Drive path: show drive letter
-                short_path = f"{path_text[:2]}\\"
-            elif path_text.startswith("//"):
-                # Relative path
-                short_path = "// (relative)"
-            else:
-                short_path = path_text[:15] + "..." if len(path_text) > 15 else path_text
-            layout.label(text=short_path, icon='FILE_FOLDER')
-            
-        elif self.layout_type in {'GRID'}:
-            layout.alignment = 'CENTER'
-            layout.label(text="", icon=custom_icon)
-
-# Properties for a single linked library file
-class LinkedLibraryItem(PropertyGroup):
-    filepath: StringProperty(name="File Path", description="Path to the linked .blend file")
-    name: StringProperty(name="Name", description="Name of the linked .blend file")
-    is_missing: BoolProperty(name="Missing", description="True if the linked file is not found")
-    is_indirect: BoolProperty(name="Is Indirect", description="True if this is an indirectly linked library")
-    is_expanded: BoolProperty(name="Expanded", description="Whether this library item is expanded in the UI", default=True)
-    linked_datablocks: CollectionProperty(type=LinkedDatablockItem, name="Linked Datablocks")
-
-class DynamicLinkManagerProperties(PropertyGroup):
-    linked_libraries: CollectionProperty(type=LinkedLibraryItem, name="Linked Libraries")
-    linked_libraries_index: IntProperty(
-        name="Linked Libraries Index",
-        description="Index of the selected linked library",
-        default=0
-    )
-    linked_assets_count: IntProperty(
-        name="Linked Assets Count",
-        description="Number of linked assets found in scene",
-        default=0
-    )
-    
-    linked_libraries_expanded: BoolProperty(
-        name="Linked Libraries Expanded",
-        description="Whether the linked libraries section is expanded",
-        default=True
-    )
-    
-    selected_asset_path: StringProperty(
-        name="Selected Asset Path",
-        description="Path to the currently selected asset",
-        default=""
-    )
-
-# Addon preferences for search paths
-class DynamicLinkManagerPreferences(AddonPreferences):
-    bl_idname = __package__
-    
-    search_paths: CollectionProperty(
-        type=SearchPathItem,
-        name="Search Paths",
-        description="Paths to search for missing linked libraries"
-    )
-    
-    def draw(self, context):
-        layout = self.layout
-        
-                        # Search paths section
-        box = layout.box()
-        box.label(text="Default Search Paths for Missing Libraries")
-        
-        # Add button - right-justified
-        row = box.row()
-        row.alignment = 'RIGHT'
-        row.operator("dlm.add_search_path", text="Add search path", icon='ADD')
-        
-                            # List search paths
-        for i, path_item in enumerate(self.search_paths):
-            row = box.row()
-            row.prop(path_item, "path", text=f"Search path {i+1}")
-            # Folder icon for browsing
-            row.operator("dlm.browse_search_path", text="", icon='FILE_FOLDER').index = i
-            # Remove button
-            row.operator("dlm.remove_search_path", text="", icon='REMOVE').index = i
-
-class DLM_PT_main_panel(Panel):
-    bl_space_type = 'VIEW_3D'
-    bl_region_type = 'UI'
-    bl_category = 'Dynamic Link Manager'
-    bl_label = "Dynamic Link Manager"
-    
-    def get_short_path(self, filepath):
-        """Extract a short, readable path from a full filepath"""
-        if not filepath:
-            return "Unknown"
-        
-        # Handle relative paths
-        if filepath.startswith("//"):
-            return "// (relative)"
-        
-        # Handle Windows network paths
-        if filepath.startswith("\\\\"):
-            # Extract server name (e.g., \\NAS\ or \\NEXUS\)
-            parts = filepath.split("\\")
-            if len(parts) >= 3:
-                return f"\\\\{parts[2]}\\"
-            return "\\\\ (network)"
-        
-        # Handle Windows drive paths
-        if len(filepath) >= 2 and filepath[1] == ':':
-            return f"{filepath[:2]}\\"
-        
-        # Handle Unix-style paths
-        if filepath.startswith("/"):
-            parts = filepath.split("/")
-            if len(parts) >= 2:
-                return f"/{parts[1]}/"
-            return "/ (root)"
-        
-        # Fallback
-        return "Unknown"
-    
-    def draw_header(self, context):
-        layout = self.layout
-        layout.operator("preferences.addon_show", text="", icon='PREFERENCES').module = __package__
-    
-    def draw(self, context):
-        layout = self.layout
-        props = context.scene.dynamic_link_manager
-        
-        # Path management buttons
-        row = layout.row()
-        row.operator("dlm.make_paths_relative", text="Make Paths Relative", icon='FILE_PARENT')
-        row.operator("dlm.make_paths_absolute", text="Make Paths Absolute", icon='FILE_FOLDER')
-        
-        # Main scan section
-        box = layout.box()
-        box.label(text="Linked Libraries Analysis")
-        row = box.row()
-        row.operator("dlm.scan_linked_assets", text="Scan Linked Assets", icon='FILE_REFRESH')
-        
-        # Show total count and missing count
-        missing_count = sum(1 for lib in props.linked_libraries if lib.is_missing)
-        if missing_count > 0:
-            row.label(text=f"({props.linked_assets_count} libraries, {missing_count} missing)", icon='ERROR')
-        else:
-            row.label(text=f"({props.linked_assets_count} libraries)")
-        
-        # Show more detailed info if we have results
-        if props.linked_assets_count > 0:
-            # Linked Libraries section with single dropdown
-            row = box.row(align=True)
-            
-            # Dropdown arrow for the entire section
-            icon = 'DISCLOSURE_TRI_DOWN' if props.linked_libraries_expanded else 'DISCLOSURE_TRI_RIGHT'
-            row.prop(props, "linked_libraries_expanded", text="", icon=icon, icon_only=True)
-            
-            # Section header
-            row.label(text="Linked Libraries:")
-            row.label(text=f"({props.linked_assets_count} libraries)")
-            
-            # Only show library details if section is expanded
-            if props.linked_libraries_expanded:
-                # Compact list view
-                row = box.row()
-                row.template_list("DLM_UL_library_list", "", props, "linked_libraries", props, "linked_libraries_index")
-                
-                # Action buttons below the list
-                row = box.row()
-                row.operator("dlm.reload_libraries", text="Reload Libraries", icon='FILE_REFRESH')
-                
-                # Search Paths Management - integrated into Linked Libraries Analysis
-                if props.linked_assets_count > 0:
-                    # Get preferences for search paths
-                    prefs = context.preferences.addons.get(__package__)
-                    
-                    # Search paths list - Each path gets its own row with folder icon
-                    if prefs and prefs.preferences.search_paths:
-                        for i, path_item in enumerate(prefs.preferences.search_paths):
-                            row = box.row()
-                            row.prop(path_item, "path", text=f"Search path {i+1}")
-                            # Folder icon for browsing
-                            row.operator("dlm.browse_search_path", text="", icon='FILE_FOLDER').index = i
-                            # Remove button
-                            row.operator("dlm.remove_search_path", text="", icon='REMOVE').index = i
-                    
-                    # Add button - Just the + button, right-justified
-                    row = box.row()
-                    row.alignment = 'RIGHT'
-                    row.operator("dlm.add_search_path", text="Add search path", icon='ADD')
-                    
-                    # Main action button
-                    if missing_count > 0:
-                        row = box.row()
-                        row.operator("dlm.find_libraries_in_folders", text="Find libraries in these folders", icon='VIEWZOOM')
-                
-                # Show details of selected item at the bottom
-                if props.linked_libraries and 0 <= props.linked_libraries_index < len(props.linked_libraries):
-                    selected_lib = props.linked_libraries[props.linked_libraries_index]
-                    info_box = box.box()
-                    
-                    # Make entire box red if library is missing
-                    if selected_lib.is_missing:
-                        info_box.alert = True
-                    
-                    info_box.label(text=f"Selected: {selected_lib.name}")
-                    
-                    if selected_lib.is_missing:
-                        row = info_box.row()
-                        row.label(text="Status: MISSING", icon='ERROR')
-                    elif selected_lib.is_indirect:
-                        row = info_box.row()
-                        row.label(text="Status: INDIRECT", icon='INFO')
-                    else:
-                        row = info_box.row()
-                        row.label(text="Status: OK", icon='FILE_BLEND')
-                    
-                    # Show full path and Open Blend button
-                    row = info_box.row()
-                    row.label(text=f"Path: {selected_lib.filepath}", icon='FILE_FOLDER')
-
-                    row = info_box.row()
-                    row.operator("dlm.open_linked_file", text="Open Blend", icon='FILE_BLEND').filepath = selected_lib.filepath
-
-                    # Relocate (context-free): lets the user pick a new .blend and we reload the library
-                    row = info_box.row()
-                    op = row.operator("dlm.relocate_single_library", text="Relocate Library", icon='FILE_FOLDER')
-                    op.target_filepath = selected_lib.filepath
-                    
-
-
-def register():
-    bpy.utils.register_class(SearchPathItem)
-    bpy.utils.register_class(LinkedDatablockItem)
-    bpy.utils.register_class(DLM_UL_library_list)
-    bpy.utils.register_class(LinkedLibraryItem)
-    bpy.utils.register_class(DynamicLinkManagerProperties)
-    bpy.utils.register_class(DynamicLinkManagerPreferences)
-    bpy.utils.register_class(DLM_PT_main_panel)
-    
-    # Register properties to scene
-    bpy.types.Scene.dynamic_link_manager = bpy.props.PointerProperty(type=DynamicLinkManagerProperties)
-
-def unregister():
-    # Unregister properties from scene
-    del bpy.types.Scene.dynamic_link_manager
-    
-    bpy.utils.unregister_class(DLM_PT_main_panel)
-    bpy.utils.unregister_class(DynamicLinkManagerPreferences)
-    bpy.utils.unregister_class(DynamicLinkManagerProperties)
-    bpy.utils.unregister_class(LinkedLibraryItem)
-    bpy.utils.unregister_class(DLM_UL_library_list)
-    bpy.utils.unregister_class(LinkedDatablockItem)
-    bpy.utils.unregister_class(SearchPathItem)

ui/__init__.py

@@ -0,0 +1,24 @@
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+from .operators import OPERATOR_CLASSES
+from .panels import DLM_PT_main_panel, DLM_UL_library_list
+from .preferences import DynamicLinkManagerPreferences
+from . import properties
+
+PANEL_CLASSES = [DLM_PT_main_panel, DLM_UL_library_list]
+
+CLASSES = (
+    properties.SearchPathItem,
+    properties.LinkedDatablockItem,
+    properties.LinkedLibraryItem,
+    properties.DynamicLinkManagerProperties,
+    DynamicLinkManagerPreferences,
+    DLM_UL_library_list,
+    DLM_PT_main_panel,
+    *OPERATOR_CLASSES,
+)
+
+__all__ = ["CLASSES", "OPERATOR_CLASSES", "PANEL_CLASSES", "DynamicLinkManagerPreferences", "properties"]

ui/operators.py

@@ -0,0 +1,307 @@
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+import bpy
+import os
+from bpy.types import Operator
+from bpy.props import StringProperty, IntProperty
+
+ADDON_NAME = __package__.rsplit(".", 1)[0] if "." in __package__ else __package__
+
+
+def _prefs(context):
+    return context.preferences.addons.get(ADDON_NAME)
+
+
+class DLM_OT_replace_linked_asset(Operator):
+    bl_idname = "dlm.replace_linked_asset"
+    bl_label = "Replace Linked Asset"
+    bl_options = {"REGISTER", "UNDO"}
+    filepath: StringProperty(name="File Path", description="Path to the new asset file", subtype="FILE_PATH")
+
+    def execute(self, context):
+        obj = context.active_object
+        if not obj:
+            self.report({"ERROR"}, "No object selected")
+            return {"CANCELLED"}
+        if getattr(obj, "library", None):
+            self.report({"INFO"}, f"Object '{obj.name}' is linked from: {obj.library.filepath}")
+            return {"FINISHED"}
+        if obj.data and getattr(obj.data, "library", None) and obj.data.library:
+            self.report({"INFO"}, f"Object '{obj.name}' has linked data from: {obj.data.library.filepath}")
+            return {"FINISHED"}
+        if obj.type == "ARMATURE" and obj.data and obj.data.name in bpy.data.armatures:
+            ad = bpy.data.armatures[obj.data.name]
+            if getattr(ad, "library", None) and ad.library:
+                self.report({"INFO"}, f"Armature '{obj.name}' data is linked from: {ad.library.filepath}")
+                return {"FINISHED"}
+        self.report({"ERROR"}, "Selected object is not a linked asset")
+        return {"CANCELLED"}
+
+    def invoke(self, context, event):
+        context.window_manager.fileselect_add(self)
+        return {"RUNNING_MODAL"}
+
+
+class DLM_OT_scan_linked_assets(Operator):
+    bl_idname = "dlm.scan_linked_assets"
+    bl_label = "Scan Linked Libraries"
+    bl_options = {"REGISTER"}
+
+    def execute(self, context):
+        from ..ops import library
+
+        return library.scan_linked_assets(context, self.report)
+
+
+class DLM_OT_find_libraries_in_folders(Operator):
+    bl_idname = "dlm.find_libraries_in_folders"
+    bl_label = "Find Libraries in Folders"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        from ..ops import library
+
+        return library.find_libraries_in_folders(context, self.report, ADDON_NAME)
+
+
+class DLM_OT_open_linked_file(Operator):
+    bl_idname = "dlm.open_linked_file"
+    bl_label = "Open Linked File"
+    bl_options = {"REGISTER"}
+    filepath: StringProperty(name="File Path", default="")
+
+    def execute(self, context):
+        if not self.filepath:
+            self.report({"ERROR"}, "No file path specified")
+            return {"CANCELLED"}
+        try:
+            bpy.ops.wm.path_open(filepath=self.filepath)
+            self.report({"INFO"}, f"Opening linked file: {self.filepath}")
+        except Exception as e:
+            self.report({"ERROR"}, f"Failed to open linked file: {e}")
+            return {"CANCELLED"}
+        return {"FINISHED"}
+
+
+class DLM_OT_add_search_path(Operator):
+    bl_idname = "dlm.add_search_path"
+    bl_label = "Add Search Path"
+    bl_options = {"REGISTER"}
+
+    def execute(self, context):
+        prefs = _prefs(context)
+        if prefs:
+            p = prefs.preferences.search_paths.add()
+            p.path = "//"
+            self.report({"INFO"}, f"Added search path: {p.path}")
+        return {"FINISHED"}
+
+
+class DLM_OT_remove_search_path(Operator):
+    bl_idname = "dlm.remove_search_path"
+    bl_label = "Remove Search Path"
+    bl_options = {"REGISTER"}
+    index: IntProperty(name="Index", default=0)
+
+    def execute(self, context):
+        prefs = _prefs(context)
+        if prefs and prefs.preferences.search_paths and 0 <= self.index < len(prefs.preferences.search_paths):
+            prefs.preferences.search_paths.remove(self.index)
+            self.report({"INFO"}, f"Removed search path at index {self.index}")
+        return {"FINISHED"}
+
+
+class DLM_OT_attempt_relink(Operator):
+    bl_idname = "dlm.attempt_relink"
+    bl_label = "Attempt Relink"
+    bl_options = {"REGISTER"}
+
+    def execute(self, context):
+        from ..ops import library
+
+        return library.attempt_relink(context, self.report, ADDON_NAME)
+
+
+class DLM_OT_browse_search_path(Operator):
+    bl_idname = "dlm.browse_search_path"
+    bl_label = "Browse Search Path"
+    bl_options = {"REGISTER"}
+    index: IntProperty(name="Index", default=0)
+    filepath: StringProperty(name="Search Path", subtype="DIR_PATH")
+
+    def execute(self, context):
+        prefs = _prefs(context)
+        if prefs and prefs.preferences.search_paths and 0 <= self.index < len(prefs.preferences.search_paths):
+            prefs.preferences.search_paths[self.index].path = self.filepath
+            self.report({"INFO"}, f"Updated search path {self.index + 1}: {self.filepath}")
+        return {"FINISHED"}
+
+    def invoke(self, context, event):
+        prefs = _prefs(context)
+        if prefs and prefs.preferences.search_paths and 0 <= self.index < len(prefs.preferences.search_paths):
+            self.filepath = prefs.preferences.search_paths[self.index].path
+        context.window_manager.fileselect_add(self)
+        return {"RUNNING_MODAL"}
+
+
+class DLM_OT_reload_libraries(Operator):
+    bl_idname = "dlm.reload_libraries"
+    bl_label = "Reload Libraries"
+    bl_options = {"REGISTER"}
+
+    def execute(self, context):
+        try:
+            bpy.ops.outliner.lib_operation(type="RELOAD")
+            self.report({"INFO"}, "Library reload operation completed")
+        except Exception:
+            try:
+                for lib in bpy.data.libraries:
+                    if lib.filepath and os.path.exists(bpy.path.abspath(lib.filepath)):
+                        lib.reload()
+                self.report({"INFO"}, "Libraries reloaded manually")
+            except Exception as e:
+                self.report({"ERROR"}, f"Failed to reload libraries: {e}")
+                return {"CANCELLED"}
+        return {"FINISHED"}
+
+
+class DLM_OT_make_paths_relative(Operator):
+    bl_idname = "dlm.make_paths_relative"
+    bl_label = "Make Paths Relative"
+    bl_options = {"REGISTER"}
+
+    def execute(self, context):
+        try:
+            bpy.ops.file.make_paths_relative()
+            self.report({"INFO"}, "All file paths made relative")
+        except Exception as e:
+            self.report({"ERROR"}, f"Failed to make paths relative: {e}")
+            return {"CANCELLED"}
+        return {"FINISHED"}
+
+
+class DLM_OT_make_paths_absolute(Operator):
+    bl_idname = "dlm.make_paths_absolute"
+    bl_label = "Make Paths Absolute"
+    bl_options = {"REGISTER"}
+
+    def execute(self, context):
+        try:
+            bpy.ops.file.make_paths_absolute()
+            self.report({"INFO"}, "All file paths made absolute")
+        except Exception as e:
+            self.report({"ERROR"}, f"Failed to make paths absolute: {e}")
+            return {"CANCELLED"}
+        return {"FINISHED"}
+
+
+class DLM_OT_relocate_single_library(Operator):
+    bl_idname = "dlm.relocate_single_library"
+    bl_label = "Relocate Library"
+    bl_options = {"REGISTER", "UNDO"}
+    target_filepath: StringProperty(name="Current Library Path", default="")
+    filepath: StringProperty(name="New Library File", subtype="FILE_PATH", default="")
+
+    def execute(self, context):
+        if not self.target_filepath or not self.filepath:
+            self.report({"ERROR"}, "No target or new file specified")
+            return {"CANCELLED"}
+        abs_match = bpy.path.abspath(self.target_filepath) if self.target_filepath else ""
+        library = None
+        for lib in bpy.data.libraries:
+            try:
+                if lib.filepath and bpy.path.abspath(lib.filepath) == abs_match:
+                    library = lib
+                    break
+            except Exception:
+                if lib.filepath == self.target_filepath:
+                    library = lib
+                    break
+        if not library:
+            self.report({"ERROR"}, "Could not resolve the selected library")
+            return {"CANCELLED"}
+        try:
+            library.filepath = self.filepath
+            library.reload()
+            self.report({"INFO"}, f"Relocated to: {self.filepath}")
+        except Exception as e:
+            self.report({"ERROR"}, f"Failed to relocate: {e}")
+            return {"CANCELLED"}
+        return {"FINISHED"}
+
+    def invoke(self, context, event):
+        if self.target_filepath:
+            try:
+                self.filepath = bpy.path.abspath(self.target_filepath)
+            except Exception:
+                self.filepath = self.target_filepath
+        context.window_manager.fileselect_add(self)
+        return {"RUNNING_MODAL"}
+
+
+class DLM_OT_run_character_migration(Operator):
+    bl_idname = "dlm.run_character_migration"
+    bl_label = "Run Character Migration"
+    bl_options = {"REGISTER", "UNDO"}
+
+    def execute(self, context):
+        from ..ops.migrator import run_full_migration
+
+        ok, msg = run_full_migration(context)
+        if ok:
+            self.report({"INFO"}, msg)
+            return {"FINISHED"}
+        self.report({"ERROR"}, msg)
+        return {"CANCELLED"}
+
+
+class DLM_OT_picker_original_character(Operator):
+    bl_idname = "dlm.picker_original_character"
+    bl_label = "Pick Original"
+    bl_options = {"REGISTER"}
+
+    def execute(self, context):
+        obj = context.active_object
+        if not obj or obj.type != "ARMATURE":
+            self.report({"WARNING"}, "Select an armature")
+            return {"CANCELLED"}
+        context.scene.dynamic_link_manager.original_character = obj
+        self.report({"INFO"}, f"Original: {obj.name}")
+        return {"FINISHED"}
+
+
+class DLM_OT_picker_replacement_character(Operator):
+    bl_idname = "dlm.picker_replacement_character"
+    bl_label = "Pick Replacement"
+    bl_options = {"REGISTER"}
+
+    def execute(self, context):
+        obj = context.active_object
+        if not obj or obj.type != "ARMATURE":
+            self.report({"WARNING"}, "Select an armature")
+            return {"CANCELLED"}
+        context.scene.dynamic_link_manager.replacement_character = obj
+        self.report({"INFO"}, f"Replacement: {obj.name}")
+        return {"FINISHED"}
+
+
+OPERATOR_CLASSES = [
+    DLM_OT_replace_linked_asset,
+    DLM_OT_scan_linked_assets,
+    DLM_OT_find_libraries_in_folders,
+    DLM_OT_open_linked_file,
+    DLM_OT_add_search_path,
+    DLM_OT_remove_search_path,
+    DLM_OT_browse_search_path,
+    DLM_OT_attempt_relink,
+    DLM_OT_reload_libraries,
+    DLM_OT_make_paths_relative,
+    DLM_OT_make_paths_absolute,
+    DLM_OT_relocate_single_library,
+    DLM_OT_run_character_migration,
+    DLM_OT_picker_original_character,
+    DLM_OT_picker_replacement_character,
+]

ui/panels.py

@@ -0,0 +1,138 @@
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+import bpy
+from bpy.types import Panel, UIList
+from . import properties
+
+
+class DLM_UL_library_list(UIList):
+    def draw_item(self, context, layout, data, item, icon, active_data, active_propname, index):
+        if self.layout_type in {"DEFAULT", "COMPACT"}:
+            layout.scale_x = 0.4
+            layout.label(text=item.name)
+            layout.scale_x = 0.3
+            if item.is_missing:
+                layout.label(text="MISSING", icon="ERROR")
+            elif item.is_indirect:
+                layout.label(text="INDIRECT", icon="INFO")
+            else:
+                layout.label(text="OK", icon="FILE_BLEND")
+            layout.scale_x = 0.3
+            path_text = item.filepath or ""
+            if path_text.startswith("\\\\"):
+                parts = path_text.split("\\")
+                short_path = f"\\\\{parts[2]}\\" if len(parts) >= 3 else "\\\\ (network)"
+            elif len(path_text) >= 2 and path_text[1] == ":":
+                short_path = f"{path_text[:2]}\\"
+            elif path_text.startswith("//"):
+                short_path = "// (relative)"
+            else:
+                short_path = path_text[:15] + "..." if len(path_text) > 15 else path_text
+            layout.label(text=short_path, icon="FILE_FOLDER")
+        elif self.layout_type == "GRID":
+            layout.alignment = "CENTER"
+            layout.label(text="", icon="FILE_BLEND")
+
+
+def _get_short_path(filepath):
+    if not filepath:
+        return "Unknown"
+    if filepath.startswith("//"):
+        return "// (relative)"
+    if filepath.startswith("\\\\"):
+        parts = filepath.split("\\")
+        return f"\\\\{parts[2]}\\" if len(parts) >= 3 else "\\\\ (network)"
+    if len(filepath) >= 2 and filepath[1] == ":":
+        return f"{filepath[:2]}\\"
+    if filepath.startswith("/"):
+        parts = filepath.split("/")
+        return f"/{parts[1]}/" if len(parts) >= 2 else "/ (root)"
+    return "Unknown"
+
+
+class DLM_PT_main_panel(Panel):
+    bl_space_type = "VIEW_3D"
+    bl_region_type = "UI"
+    bl_category = "Dynamic Link Manager"
+    bl_label = "Dynamic Link Manager"
+
+    def draw_header(self, context):
+        layout = self.layout
+        layout.operator("preferences.addon_show", text="", icon="PREFERENCES").module = __package__.rsplit(".", 1)[0]
+
+    def draw(self, context):
+        layout = self.layout
+        props = context.scene.dynamic_link_manager
+
+        # Path management
+        row = layout.row()
+        row.operator("dlm.make_paths_relative", text="Make Paths Relative", icon="FILE_PARENT")
+        row.operator("dlm.make_paths_absolute", text="Make Paths Absolute", icon="FILE_FOLDER")
+
+        # CharMig section (placeholder; full UI in implementation step 5)
+        box = layout.box()
+        box.label(text="Character Migrator")
+        row = box.row()
+        row.prop(props, "migrator_mode", text="Automatic pair discovery")
+        row = box.row()
+        row.prop(props, "original_character", text="Original")
+        row.operator("dlm.picker_original_character", text="", icon="EYEDROPPER")
+        row = box.row()
+        row.prop(props, "replacement_character", text="Replacement")
+        row.operator("dlm.picker_replacement_character", text="", icon="EYEDROPPER")
+        row = box.row()
+        row.operator("dlm.run_character_migration", text="Run migration", icon="ARMATURE_DATA")
+
+        # Linked Libraries (own dropdown)
+        box = layout.box()
+        box.label(text="Linked Libraries Analysis")
+        row = box.row()
+        row.operator("dlm.scan_linked_assets", text="Scan Linked Assets", icon="FILE_REFRESH")
+        missing_count = sum(1 for lib in props.linked_libraries if lib.is_missing)
+        if missing_count > 0:
+            row.label(text=f"({props.linked_assets_count} libraries, {missing_count} missing)", icon="ERROR")
+        else:
+            row.label(text=f"({props.linked_assets_count} libraries)")
+        if props.linked_assets_count > 0:
+            row = box.row(align=True)
+            icon = "DISCLOSURE_TRI_DOWN" if props.linked_libraries_expanded else "DISCLOSURE_TRI_RIGHT"
+            row.prop(props, "linked_libraries_expanded", text="", icon=icon, icon_only=True)
+            row.label(text="Linked Libraries:")
+            row.label(text=f"({props.linked_assets_count} libraries)")
+            if props.linked_libraries_expanded:
+                row = box.row()
+                row.template_list("DLM_UL_library_list", "", props, "linked_libraries", props, "linked_libraries_index")
+                row = box.row()
+                row.operator("dlm.reload_libraries", text="Reload Libraries", icon="FILE_REFRESH")
+                prefs = context.preferences.addons.get(__package__.rsplit(".", 1)[0])
+                if prefs and prefs.preferences.search_paths:
+                    for i, path_item in enumerate(prefs.preferences.search_paths):
+                        row = box.row()
+                        row.prop(path_item, "path", text=f"Search path {i+1}")
+                        row.operator("dlm.browse_search_path", text="", icon="FILE_FOLDER").index = i
+                        row.operator("dlm.remove_search_path", text="", icon="REMOVE").index = i
+                row = box.row()
+                row.alignment = "RIGHT"
+                row.operator("dlm.add_search_path", text="Add search path", icon="ADD")
+                if missing_count > 0:
+                    row = box.row()
+                    row.operator("dlm.find_libraries_in_folders", text="Find libraries in these folders", icon="VIEWZOOM")
+                if props.linked_libraries and 0 <= props.linked_libraries_index < len(props.linked_libraries):
+                    selected_lib = props.linked_libraries[props.linked_libraries_index]
+                    info_box = box.box()
+                    if selected_lib.is_missing:
+                        info_box.alert = True
+                    info_box.label(text=f"Selected: {selected_lib.name}")
+                    if selected_lib.is_missing:
+                        info_box.label(text="Status: MISSING", icon="ERROR")
+                    elif selected_lib.is_indirect:
+                        info_box.label(text="Status: INDIRECT", icon="INFO")
+                    else:
+                        info_box.label(text="Status: OK", icon="FILE_BLEND")
+                    info_box.label(text=f"Path: {selected_lib.filepath}", icon="FILE_FOLDER")
+                    info_box.operator("dlm.open_linked_file", text="Open Blend", icon="FILE_BLEND").filepath = selected_lib.filepath
+                    op = info_box.operator("dlm.relocate_single_library", text="Relocate Library", icon="FILE_FOLDER")
+                    op.target_filepath = selected_lib.filepath

ui/preferences.py

@@ -0,0 +1,32 @@
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+import bpy
+from bpy.types import AddonPreferences
+from bpy.props import StringProperty, CollectionProperty
+from . import properties
+
+
+class DynamicLinkManagerPreferences(AddonPreferences):
+    bl_idname = __package__.rsplit(".", 1)[0]
+
+    search_paths: CollectionProperty(
+        type=properties.SearchPathItem,
+        name="Search Paths",
+        description="Paths to search for missing linked libraries",
+    )
+
+    def draw(self, context):
+        layout = self.layout
+        box = layout.box()
+        box.label(text="Default Search Paths for Missing Libraries")
+        row = box.row()
+        row.alignment = "RIGHT"
+        row.operator("dlm.add_search_path", text="Add search path", icon="ADD")
+        for i, path_item in enumerate(self.search_paths):
+            row = box.row()
+            row.prop(path_item, "path", text=f"Search path {i+1}")
+            row.operator("dlm.browse_search_path", text="", icon="FILE_FOLDER").index = i
+            row.operator("dlm.remove_search_path", text="", icon="REMOVE").index = i

ui/properties.py

@@ -0,0 +1,57 @@
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+import bpy
+from bpy.types import PropertyGroup
+from bpy.props import IntProperty, StringProperty, BoolProperty, CollectionProperty, PointerProperty
+
+
+class SearchPathItem(PropertyGroup):
+    path: StringProperty(
+        name="Search Path",
+        description="Path to search for missing linked libraries",
+        subtype="DIR_PATH",
+    )
+
+
+class LinkedDatablockItem(PropertyGroup):
+    name: StringProperty(name="Name", description="Name of the linked datablock")
+    type: StringProperty(name="Type", description="Type of the linked datablock")
+
+
+class LinkedLibraryItem(PropertyGroup):
+    filepath: StringProperty(name="File Path", description="Path to the linked .blend file")
+    name: StringProperty(name="Name", description="Name of the linked .blend file")
+    is_missing: BoolProperty(name="Missing", description="True if the linked file is not found")
+    is_indirect: BoolProperty(name="Is Indirect", description="True if this is an indirectly linked library")
+    is_expanded: BoolProperty(name="Expanded", default=True)
+    linked_datablocks: CollectionProperty(type=LinkedDatablockItem, name="Linked Datablocks")
+
+
+class DynamicLinkManagerProperties(PropertyGroup):
+    linked_libraries: CollectionProperty(type=LinkedLibraryItem, name="Linked Libraries")
+    linked_libraries_index: IntProperty(name="Linked Libraries Index", default=0)
+    linked_assets_count: IntProperty(name="Linked Assets Count", default=0)
+    linked_libraries_expanded: BoolProperty(name="Linked Libraries Expanded", default=True)
+    selected_asset_path: StringProperty(name="Selected Asset Path", default="")
+
+    # Character migrator (manual mode)
+    migrator_mode: BoolProperty(
+        name="Automatic",
+        description="Automatic: discover pair by Name_Rigify / Name_Rigify.001. Manual: use fields below",
+        default=False,
+    )
+    original_character: PointerProperty(
+        name="Original Character",
+        description="Armature to migrate from",
+        type=bpy.types.Object,
+        poll=lambda self, obj: obj and obj.type == "ARMATURE",
+    )
+    replacement_character: PointerProperty(
+        name="Replacement Character",
+        description="Armature to migrate to",
+        type=bpy.types.Object,
+        poll=lambda self, obj: obj and obj.type == "ARMATURE",
+    )

utils/__init__.py

@@ -0,0 +1,39 @@
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 3 of the License, or
+# (at your option) any later version.
+
+"""Shared helpers for Dynamic Link Manager."""
+
+import bpy
+
+
+def descendants(armature):
+    """Return a set of objects whose parent chain leads to the given armature."""
+    out = set()
+    for ob in bpy.data.objects:
+        p = ob.parent
+        while p:
+            if p == armature:
+                out.add(ob)
+                break
+            p = p.parent
+    return out
+
+
+def collection_containing_armature(armature):
+    """
+    Return a collection that contains the armature (for linked character context).
+    Prefers a collection whose name matches the character base (e.g. "Steve" for Steve_Rigify).
+    """
+    if not armature or armature.name not in bpy.data.objects:
+        return None
+    colls = getattr(armature, "users_collection", []) or []
+    if not colls:
+        return None
+    name = armature.name
+    base = name.replace("_Rigify", "").replace(".001", "").rstrip("0123456789.")
+    for c in colls:
+        if c.name == base or base in c.name or c.name in name:
+            return c
+    return colls[0]