moai-adk 0.25.4__py3-none-any.whl → 0.32.8__py3-none-any.whl

moai_adk/core/migration/user_selection_ui.py

@@ -0,0 +1,338 @@
+"""User Selection UI for MoAI-ADK Custom Element Restoration
+
+This module provides enhanced CLI-based user interface for selecting custom elements
+to restore from backup during MoAI-ADK updates. It features:
+
+- Interactive checkbox selection with arrow key navigation (preferred)
+- Fallback to numbered selection when curses is not available
+- Category grouping (Agents, Commands, Skills, Hooks)
+- Proper element preservation (unselected elements remain intact)
+"""
+
+from pathlib import Path
+from typing import Any, Dict, List, Optional
+
+from .custom_element_scanner import create_custom_element_scanner
+
+
+class UserSelectionUI:
+    """Enhanced CLI-based user interface for selecting custom elements to restore.
+
+    This class provides an improved CLI interface with interactive checkbox selection
+    when available, falling back to numbered selection when curses is not supported.
+    It properly preserves unselected elements and includes all categories.
+    """
+
+    def __init__(self, project_path: str | Path):
+        """Initialize the user selection UI.
+
+        Args:
+            project_path: Path to the MoAI-ADK project directory
+        """
+        self.project_path = Path(project_path).resolve()
+        self.scanner = create_custom_element_scanner(self.project_path)
+
+        # Try to import interactive UI, fall back to basic UI if not available
+        try:
+            from .interactive_checkbox_ui import create_interactive_checkbox_ui
+
+            self.interactive_ui = create_interactive_checkbox_ui(self.project_path)
+            self.use_interactive = True
+        except Exception:
+            self.interactive_ui = None
+            self.use_interactive = False
+
+    def prompt_user_selection(self, backup_available: bool = True) -> Optional[List[str]]:
+        """Prompt user to select custom elements for restoration.
+
+        Args:
+            backup_available: Whether backup is available for restoration
+
+        Returns:
+            List of selected element paths, or None if no selection made
+            or no elements available
+
+        Example:
+            >>> ui = UserSelectionUI("/project")
+            >>> selected = ui.prompt_user_selection()
+            >>> print(f"Selected {len(selected)} elements")
+        """
+        # Try interactive UI first
+        if self.use_interactive and self.interactive_ui:
+            try:
+                return self.interactive_ui.prompt_user_selection(backup_available)
+            except Exception as e:
+                print(f"⚠️ Interactive UI failed: {e}")
+                print("Falling back to basic selection mode...")
+
+        # Fallback to basic selection
+        return self._basic_selection_mode(backup_available)
+
+    def _basic_selection_mode(self, backup_available: bool) -> Optional[List[str]]:
+        """Basic numbered selection mode (fallback when interactive UI not available).
+
+        Args:
+            backup_available: Whether backup is available for restoration
+
+        Returns:
+            List of selected element paths, or None if cancelled
+        """
+        # Get custom elements organized by category
+        elements_by_category = self._get_elements_by_category()
+
+        # No custom elements found
+        if not any(elements_by_category.values()):
+            print("\n✅ No custom elements found in project.")
+            print("   All elements are part of the official MoAI-ADK template.")
+            return None
+
+        # Display elements by category
+        print("\n" + "=" * 60)
+        print("🔍 Custom Elements Detected (Basic Mode)")
+        print("=" * 60)
+        print("These elements are not part of the official MoAI-ADK template:")
+        print()
+
+        element_index = 1
+        element_map = {}  # Map index to element path
+
+        for category, elements in elements_by_category.items():
+            if not elements:
+                continue
+
+            print(f"\n📁 {category} ({len(elements)}):")
+            for element in elements:
+                status = "✓ Available" if backup_available else "⚠ No backup"
+                print(f"  {element_index:2d}. {element['name']:<35} {status}")
+                element_map[element_index] = element["path"]
+                element_index += 1
+
+        # Show selection instructions
+        print()
+        if not backup_available:
+            print("⚠️ No backup available. Cannot restore custom elements.")
+            print("💡 Run 'moai-adk update' without --force to create a backup first.")
+            return None
+
+        print("💡 Selection Instructions:")
+        print("   • Enter numbers separated by commas (e.g., 1,3,5)")
+        print("   • Use 'all' to select all elements")
+        print("   • Press Enter with empty input to cancel")
+
+        # Get user input
+        try:
+            user_input = input("\nSelect elements to restore: ").strip()
+        except (KeyboardInterrupt, EOFError):
+            print("\n⚠️ Selection cancelled.")
+            return None
+
+        # Process user input
+        if not user_input:
+            print("No elements selected.")
+            return None
+
+        # Check for "all" shortcut
+        if user_input.lower() == "all":
+            all_elements = list(element_map.values())
+            # Ask for confirmation when selecting all elements
+            if self.confirm_selection(all_elements):
+                return all_elements
+            else:
+                return None
+
+        # Parse numbered selection
+        selected_elements = []
+        try:
+            indices = [int(x.strip()) for x in user_input.split(",") if x.strip()]
+            for idx in indices:
+                if idx in element_map:
+                    selected_elements.append(element_map[idx])
+                else:
+                    print(f"⚠️ Invalid number: {idx}")
+        except ValueError:
+            print("⚠️ Invalid input. Please enter numbers separated by commas.")
+            return None
+
+        if not selected_elements:
+            print("No valid selections made.")
+            return None
+
+        # Ask for confirmation
+        if self.confirm_selection(selected_elements):
+            return selected_elements
+        else:
+            return None
+
+    def _get_elements_by_category(self) -> Dict[str, List[Dict]]:
+        """Organize custom elements by category.
+
+        Returns:
+            Dictionary mapping category names to lists of elements
+        """
+        custom_elements = self.scanner.scan_custom_elements()
+        organized: Dict[str, List[Dict[str, Any]]] = {
+            "Agents": [],
+            "Commands": [],
+            "Skills": [],
+            "Hooks": [],
+        }
+
+        # Add skills (which are directories)
+        if "skills" in custom_elements:
+            for skill in custom_elements["skills"]:
+                organized["Skills"].append({"name": skill.name, "path": str(skill.path), "type": "skill"})
+
+        # Add file-based elements
+        for element_type in ["agents", "commands", "hooks"]:
+            if element_type in custom_elements:
+                category_name = element_type.capitalize()
+                for element_path in custom_elements[element_type]:
+                    element_name = Path(element_path).name
+                    organized[category_name].append(
+                        {
+                            "name": element_name,
+                            "path": str(element_path),
+                            "type": element_type.rstrip("s"),  # Remove plural 's'
+                        }
+                    )
+
+        return organized
+
+    def _parse_selection(self, user_input: str, custom_elements: List[Dict[str, str]]) -> List[str]:
+        """Parse user selection input with enhanced support for multiple separators.
+
+        Args:
+            user_input: User's input string (can use commas, spaces, semicolons, etc.)
+            custom_elements: List of available custom elements
+
+        Returns:
+            List of selected element paths
+        """
+        selected_paths = []
+
+        # Enhanced parsing: handle multiple separator types (comma, space, semicolon, backslash)
+        import re
+
+        # Split by common separators and clean up
+        selections = re.split(r"[,\s;\\]+", user_input.strip())
+        selections = [s.strip() for s in selections if s.strip()]
+
+        for selection in selections:
+            try:
+                # Parse as number
+                index = int(selection)
+                # Find element with this index (1-based)
+                for element in custom_elements:
+                    if element["index"] == index:
+                        selected_paths.append(element["path"])
+                        break
+                else:
+                    print(f"⚠️ Invalid selection: {selection} (not in available list)")
+            except ValueError:
+                # Try to parse as element name (for enhanced UX)
+                found = False
+                for element in custom_elements:
+                    if (
+                        selection.lower() in element["name"].lower()
+                        or selection.lower() in element["display_name"].lower()
+                    ):
+                        selected_paths.append(element["path"])
+                        found = True
+                        break
+
+                if not found:
+                    print(f"⚠️ Invalid selection: {selection} (not a number or matching element name)")
+
+        return selected_paths
+
+    def confirm_selection(self, selected_elements: List[str]) -> bool:
+        """Confirm user's selection before proceeding with restoration.
+
+        Args:
+            selected_elements: List of selected element paths
+
+        Returns:
+            True if user confirms, False otherwise
+        """
+        print("\n📋 Selection Summary:")
+        print("-" * 40)
+        for i, element_path in enumerate(selected_elements, 1):
+            element_name = Path(element_path).name
+            element_type = self._get_element_type(element_path)
+            print(f"  {i}. {element_name} ({element_type})")
+
+        print("-" * 40)
+        print(f"Total elements selected: {len(selected_elements)}")
+
+        try:
+            confirm = input("\nConfirm restoration? (y/N): ").strip().lower()
+            return confirm in ["y", "yes", ""]
+        except (KeyboardInterrupt, EOFError):
+            print("\n⚠️ Restoration cancelled.")
+            return False
+
+    def _get_element_type(self, element_path: str) -> str:
+        """Get element type from path.
+
+        Args:
+            element_path: Path to element
+
+        Returns:
+            Element type string (agent, command, skill, hook)
+        """
+        path = Path(element_path)
+        parts = path.parts
+
+        if "agents" in parts:
+            return "agent"
+        elif "commands" in parts:
+            return "command"
+        elif "skills" in parts:
+            return "skill"
+        elif "hooks" in parts:
+            return "hook"
+        else:
+            return "unknown"
+
+
+def display_selection_instructions():
+    """Display instructions for using the enhanced selection interface."""
+    print(
+        """
+📖 Enhanced Selection Instructions:
+  • Enter numbers separated by spaces, commas, semicolons (e.g., 1 3,4 or 1;3\\4)
+  • Use 'all' to select all elements
+  • Try partial names for convenience (e.g., 'yoda' or 'agent')
+  • Press Enter with empty input to cancel
+  • Use Ctrl+C to interrupt selection
+
+📂 Element Types:
+  • agent: Custom agent for specific tasks
+  • command: Custom slash command for workflows
+  • skill: Custom skill with enhanced capabilities
+  • hook: Custom hook for system integration
+
+💡 Pro Tips:
+  • Mixed separators work: "1,3;5\\7"
+  • Partial name matching: "my-agen" matches "my-agent"
+  • Case insensitive: "YODA" matches "yoda"
+    """
+    )
+
+
+def create_user_selection_ui(project_path: str | Path) -> UserSelectionUI:
+    """Factory function to create a UserSelectionUI.
+
+    Args:
+        project_path: Path to the MoAI-ADK project directory
+
+    Returns:
+        Configured UserSelectionUI instance
+
+    Example:
+        >>> ui = create_user_selection_ui("/path/to/project")
+        >>> selected = ui.prompt_user_selection()
+        >>> if selected:
+        >>>     ui.confirm_selection(selected)
+    """
+    return UserSelectionUI(Path(project_path).resolve())

moai_adk/core/migration/version_detector.py

@@ -8,7 +8,7 @@ which migrations are needed.
 import json
 import logging
 from pathlib import Path
-from typing import Dict, List, Optional
+from typing import Any, Dict
 
 logger = logging.getLogger(__name__)
 
@@ -27,9 +27,7 @@ class VersionDetector:
         self.old_config = self.project_root / ".moai" / "config.json"
         self.new_config = self.project_root / ".moai" / "config" / "config.json"
         self.old_statusline = self.project_root / ".claude" / "statusline-config.yaml"
-        self.new_statusline = (
-            self.project_root / ".moai" / "config" / "statusline-config.yaml"
-        )
+        self.new_statusline = self.project_root / ".moai" / "config" / "statusline-config.yaml"
 
     def detect_version(self) -> str:
         """
@@ -76,7 +74,7 @@ class VersionDetector:
         # Version 0.23.0 or earlier needs migration
         return True
 
-    def get_migration_plan(self) -> Dict[str, List[Dict[str, str]]]:
+    def get_migration_plan(self) -> Dict[str, Any]:
         """
         Get detailed migration plan
 
@@ -88,7 +86,7 @@ class VersionDetector:
                 "cleanup": ["old_file1", "old_file2"]
             }
         """
-        plan = {"move": [], "create": [], "cleanup": []}
+        plan: Dict[str, Any] = {"move": [], "create": [], "cleanup": []}
 
         if not self.needs_migration():
             return plan
@@ -120,13 +118,11 @@ class VersionDetector:
         if self.old_config.exists():
             plan["cleanup"].append(str(self.old_config.relative_to(self.project_root)))
         if self.old_statusline.exists():
-            plan["cleanup"].append(
-                str(self.old_statusline.relative_to(self.project_root))
-            )
+            plan["cleanup"].append(str(self.old_statusline.relative_to(self.project_root)))
 
         return plan
 
-    def get_version_info(self) -> Dict[str, Optional[str]]:
+    def get_version_info(self) -> Dict[str, Any]:
         """
         Get detailed version information
 

moai_adk/core/migration/version_migrator.py

@@ -7,7 +7,7 @@ and cleanup processes for automatic project upgrades.
 
 import logging
 from pathlib import Path
-from typing import Dict
+from typing import Any, Dict
 
 from .backup_manager import BackupManager
 from .file_migrator import FileMigrator
@@ -49,7 +49,7 @@ class VersionMigrator:
         """
         return self.detector.needs_migration()
 
-    def get_migration_info(self) -> Dict[str, any]:
+    def get_migration_info(self) -> Dict[str, Any]:
         """
         Get detailed migration information
 
@@ -191,7 +191,7 @@ class VersionMigrator:
         logger.debug("All verification checks passed")
         return True
 
-    def check_status(self) -> Dict[str, any]:
+    def check_status(self) -> Dict[str, Any]:
         """
         Check migration status and return detailed information
 

moai_adk/core/performance/cache_system.py

@@ -85,12 +85,12 @@ class CacheSystem:
 
     def _cleanup_expired_files(self) -> None:
         """Remove expired cache files."""
-        current_time = time.time()
+        time.time()
         for file_name in os.listdir(self.cache_dir):
             if file_name.endswith(self.file_extension):
                 file_path = os.path.join(self.cache_dir, file_name)
                 try:
-                    with open(file_path, "r") as f:
+                    with open(file_path, "r", encoding="utf-8") as f:
                         data = json.load(f)
 
                     if self._is_expired(data):
@@ -105,8 +105,8 @@ class CacheSystem:
     def _write_data(self, file_path: str, data: Dict[str, Any]) -> None:
         """Write data to file with error handling."""
         try:
-            with open(file_path, "w") as f:
-                json.dump(data, f, indent=2)
+            with open(file_path, "w", encoding="utf-8") as f:
+                json.dump(data, f, indent=2, ensure_ascii=False)
         except (OSError, TypeError) as e:
             raise OSError(f"Failed to write cache file {file_path}: {e}")
 
@@ -116,7 +116,7 @@ class CacheSystem:
             return None
 
         try:
-            with open(file_path, "r") as f:
+            with open(file_path, "r", encoding="utf-8") as f:
                 return json.load(f)
         except (json.JSONDecodeError, OSError):
             # File is corrupted, remove it
@@ -242,16 +242,14 @@ class CacheSystem:
         count = 0
         for file_name in os.listdir(self.cache_dir):
             if file_name.endswith(self.file_extension):
-                file_path = os.path.join(self.cache_dir, file_name)
+                os.path.join(self.cache_dir, file_name)
                 key = file_name[: -len(self.file_extension)]  # Remove extension
 
                 if self.exists(key):
                     count += 1
         return count
 
-    def set_if_not_exists(
-        self, key: str, value: Any, ttl: Optional[float] = None
-    ) -> bool:
+    def set_if_not_exists(self, key: str, value: Any, ttl: Optional[float] = None) -> bool:
         """
         Set a value only if the key doesn't exist.
 
@@ -298,7 +296,7 @@ class CacheSystem:
         """
         total_files = 0
         expired_files = 0
-        current_time = time.time()
+        time.time()
 
         for file_name in os.listdir(self.cache_dir):
             if file_name.endswith(self.file_extension):