moai-adk 0.8.0__py3-none-any.whl → 1.1.0__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

@@ -0,0 +1,243 @@
+"""
+Version detection module for MoAI-ADK projects
+
+Detects the current version of a project and determines
+which migrations are needed.
+"""
+
+import json
+import logging
+from pathlib import Path
+from typing import Any, Dict, Optional
+
+import yaml
+
+logger = logging.getLogger(__name__)
+
+
+class VersionDetector:
+    """Detects project version and migration requirements"""
+
+    def __init__(self, project_root: Path):
+        """
+        Initialize version detector
+
+        Args:
+            project_root: Root directory of the project
+        """
+        self.project_root = Path(project_root)
+        # Legacy config paths (pre-v0.24.0)
+        self.old_config = self.project_root / ".moai" / "config.json"
+        # Intermediate config path (v0.24.0)
+        self.intermediate_config = self.project_root / ".moai" / "config" / "config.json"
+        # New section YAML paths (v0.36.0+)
+        self.sections_dir = self.project_root / ".moai" / "config" / "sections"
+        self.system_yaml = self.sections_dir / "system.yaml"
+        # Statusline config paths
+        self.old_statusline = self.project_root / ".claude" / "statusline-config.yaml"
+        self.new_statusline = self.project_root / ".moai" / "config" / "statusline-config.yaml"
+
+    def _read_yaml_file(self, file_path: Path) -> Optional[Dict[str, Any]]:
+        """
+        Read a YAML file safely
+
+        Args:
+            file_path: Path to the YAML file
+
+        Returns:
+            Dictionary with file contents, or None if read failed
+        """
+        try:
+            if file_path.exists():
+                with open(file_path, "r", encoding="utf-8") as f:
+                    return yaml.safe_load(f)
+        except Exception as e:
+            logger.warning(f"Failed to read YAML file {file_path}: {e}")
+        return None
+
+    def _get_version_from_section_yaml(self) -> Optional[str]:
+        """
+        Get version from section YAML files (new format)
+
+        Returns:
+            Version string from system.yaml, or None if not found
+        """
+        system_data = self._read_yaml_file(self.system_yaml)
+        if system_data and "moai" in system_data:
+            version = system_data["moai"].get("version")
+            if version:
+                return str(version)
+        return None
+
+    def detect_version(self) -> str:
+        """
+        Detect current project version based on file structure
+
+        Returns:
+            Version string (e.g., "0.23.0", "0.24.0+", "0.36.0+", "unknown")
+        """
+        # Check if using new section YAML format (v0.36.0+)
+        if self.sections_dir.exists() and self.system_yaml.exists():
+            version = self._get_version_from_section_yaml()
+            if version:
+                return version
+            return "0.36.0+"
+
+        # Check if already migrated to v0.24.0+ (intermediate config.json)
+        if self.intermediate_config.exists():
+            try:
+                with open(self.intermediate_config, "r", encoding="utf-8") as f:
+                    config_data = json.load(f)
+                    if "moai_version" in config_data:
+                        return config_data["moai_version"]
+                    return "0.24.0+"
+            except Exception as e:
+                logger.warning(f"Failed to read intermediate config: {e}")
+                return "0.24.0+"
+
+        # Check if v0.23.0 or earlier (old config.json at .moai/config.json)
+        if self.old_config.exists():
+            try:
+                with open(self.old_config, "r", encoding="utf-8") as f:
+                    config_data = json.load(f)
+                    # Try to get version from config
+                    if "moai_version" in config_data:
+                        return config_data["moai_version"]
+                    return "0.23.0"
+            except Exception as e:
+                logger.warning(f"Failed to read old config: {e}")
+                return "0.23.0"
+
+        return "unknown"
+
+    def needs_migration(self) -> bool:
+        """
+        Check if project needs migration
+
+        Returns:
+            True if migration is needed, False otherwise
+        """
+        version = self.detect_version()
+        if version == "unknown":
+            logger.info("Unknown version, assuming no migration needed")
+            return False
+
+        # Check if using new section YAML format (v0.36.0+)
+        if self.sections_dir.exists() and self.system_yaml.exists():
+            logger.info("Project already using section YAML format (v0.36.0+)")
+            return False
+
+        if version == "0.24.0+":
+            logger.info("Project on v0.24.0+, may need migration to section YAML format")
+            # Could still need migration to section YAML format
+            return not self.sections_dir.exists()
+
+        # Version 0.23.0 or earlier needs migration
+        return True
+
+    def get_migration_plan(self) -> Dict[str, Any]:
+        """
+        Get detailed migration plan
+
+        Returns:
+            Dictionary with migration actions:
+            {
+                "move": [{"from": "...", "to": "..."}],
+                "create": ["directory1", "directory2"],
+                "cleanup": ["old_file1", "old_file2"],
+                "convert": [{"from": "...", "to_dir": "...", "description": "..."}]
+            }
+        """
+        plan: Dict[str, Any] = {"move": [], "create": [], "cleanup": [], "convert": []}
+
+        if not self.needs_migration():
+            return plan
+
+        # Create config directory structure
+        config_dir = self.project_root / ".moai" / "config"
+        plan["create"].append(str(config_dir))
+
+        # Create sections directory for new YAML format
+        if not self.sections_dir.exists():
+            plan["create"].append(str(self.sections_dir))
+
+        # Handle old config.json migration (pre-v0.24.0)
+        if self.old_config.exists() and not self.intermediate_config.exists():
+            plan["move"].append(
+                {
+                    "from": str(self.old_config.relative_to(self.project_root)),
+                    "to": str(self.intermediate_config.relative_to(self.project_root)),
+                    "description": "Main configuration file (legacy)",
+                }
+            )
+
+        # Mark config.json files for conversion to section YAML
+        config_json_to_convert = None
+        if self.intermediate_config.exists():
+            config_json_to_convert = self.intermediate_config
+        elif self.old_config.exists():
+            config_json_to_convert = self.old_config
+
+        if config_json_to_convert and not self.system_yaml.exists():
+            plan["convert"].append(
+                {
+                    "from": str(config_json_to_convert.relative_to(self.project_root)),
+                    "to_dir": str(self.sections_dir.relative_to(self.project_root)),
+                    "description": "Convert config.json to section YAML files",
+                }
+            )
+
+        # Move statusline-config.yaml
+        if self.old_statusline.exists() and not self.new_statusline.exists():
+            plan["move"].append(
+                {
+                    "from": str(self.old_statusline.relative_to(self.project_root)),
+                    "to": str(self.new_statusline.relative_to(self.project_root)),
+                    "description": "Statusline configuration",
+                }
+            )
+
+        # Cleanup old files (after successful migration)
+        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)))
+        # Also cleanup intermediate config.json after conversion to YAML
+        if self.intermediate_config.exists() and self.sections_dir.exists():
+            plan["cleanup"].append(str(self.intermediate_config.relative_to(self.project_root)))
+
+        return plan
+
+    def get_version_info(self) -> Dict[str, Any]:
+        """
+        Get detailed version information
+
+        Returns:
+            Dictionary with version details
+        """
+        return {
+            "detected_version": self.detect_version(),
+            "needs_migration": self.needs_migration(),
+            "has_old_config": self.old_config.exists(),
+            "has_intermediate_config": self.intermediate_config.exists(),
+            "has_sections_dir": self.sections_dir.exists(),
+            "has_system_yaml": self.system_yaml.exists(),
+            "has_old_statusline": self.old_statusline.exists(),
+            "has_new_statusline": self.new_statusline.exists(),
+            "config_format": self._get_config_format(),
+        }
+
+    def _get_config_format(self) -> str:
+        """
+        Determine the current configuration format
+
+        Returns:
+            One of: "section_yaml", "intermediate_json", "legacy_json", "none"
+        """
+        if self.sections_dir.exists() and self.system_yaml.exists():
+            return "section_yaml"
+        elif self.intermediate_config.exists():
+            return "intermediate_json"
+        elif self.old_config.exists():
+            return "legacy_json"
+        return "none"