moai-adk 0.34.0__py3-none-any.whl → 1.1.0__py3-none-any.whl

moai_adk/core/migration/alfred_to_moai_migrator.py

@@ -6,8 +6,14 @@ Handles automatic migration from legacy alfred/ folders to new moai/ structure.
 - Installs fresh moai/ templates from package
 - Deletes alfred/ folders
 - Updates settings.json Hook paths
-- Records migration status in config.json
+- Records migration status in config.json (legacy) or config.yaml
 - Provides automatic rollback on failure
+
+BACKWARD COMPATIBILITY NOTE:
+- This migration tool maintains compatibility with legacy config.json format
+- New projects use modular section-based YAML configs (.moai/config/sections/*.yaml)
+- Migration status is recorded in whichever config format the project uses
+- Both formats are supported during migration process
 """
 
 import json

moai_adk/core/migration/backup_manager.py

@@ -3,6 +3,11 @@ Backup management module for MoAI-ADK migrations
 
 Creates and manages backups during migration processes
 to ensure data safety and enable rollback.
+
+Supports backup of:
+- Legacy config.json (.moai/config.json) - pre-v0.24.0
+- Intermediate config.json (.moai/config/config.json) - v0.24.0
+- Section YAML files (.moai/config/sections/*.yaml) - v0.36.0+
 """
 
 import json
@@ -46,15 +51,25 @@ class BackupManager:
 
         logger.info(f"Creating backup at {backup_dir}")
 
-        # Files to backup
+        # Files to backup (supporting all config formats)
         backup_targets = [
+            # Legacy config.json (pre-v0.24.0)
             self.project_root / ".moai" / "config.json",
+            # Intermediate config.json (v0.24.0)
             self.project_root / ".moai" / "config" / "config.json",
+            # Statusline configs
             self.project_root / ".claude" / "statusline-config.yaml",
             self.project_root / ".moai" / "config" / "statusline-config.yaml",
         ]
 
+        # Add section YAML files (v0.36.0+)
+        sections_dir = self.project_root / ".moai" / "config" / "sections"
+        if sections_dir.exists():
+            for yaml_file in sections_dir.glob("*.yaml"):
+                backup_targets.append(yaml_file)
+
         backed_up_files = []
+        backed_up_dirs = []
 
         for target in backup_targets:
             if target.exists():
@@ -70,21 +85,47 @@ class BackupManager:
                 backed_up_files.append(str(rel_path))
                 logger.debug(f"Backed up: {rel_path}")
 
+        # Track sections directory if it exists
+        if sections_dir.exists():
+            backed_up_dirs.append(str(sections_dir.relative_to(self.project_root)))
+
         # Save backup metadata
         metadata = {
             "timestamp": timestamp,
             "description": description,
             "backed_up_files": backed_up_files,
+            "backed_up_dirs": backed_up_dirs,
             "project_root": str(self.project_root),
+            "config_format": self._detect_config_format(),
         }
 
         metadata_path = backup_dir / "backup_metadata.json"
         with open(metadata_path, "w", encoding="utf-8") as f:
             json.dump(metadata, f, indent=2, ensure_ascii=False)
 
-        logger.info(f"✅ Backup created successfully: {backup_dir}")
+        logger.info(f"Backup created successfully: {backup_dir}")
         return backup_dir
 
+    def _detect_config_format(self) -> str:
+        """
+        Detect the current configuration format
+
+        Returns:
+            One of: "section_yaml", "intermediate_json", "legacy_json", "none"
+        """
+        sections_dir = self.project_root / ".moai" / "config" / "sections"
+        system_yaml = sections_dir / "system.yaml"
+        intermediate_config = self.project_root / ".moai" / "config" / "config.json"
+        legacy_config = self.project_root / ".moai" / "config.json"
+
+        if sections_dir.exists() and system_yaml.exists():
+            return "section_yaml"
+        elif intermediate_config.exists():
+            return "intermediate_json"
+        elif legacy_config.exists():
+            return "legacy_json"
+        return "none"
+
     def list_backups(self) -> List[Dict[str, str]]:
         """
         List all available backups
@@ -110,6 +151,7 @@ class BackupManager:
                                     "timestamp": metadata.get("timestamp", "unknown"),
                                     "description": metadata.get("description", "unknown"),
                                     "files": len(metadata.get("backed_up_files", [])),
+                                    "config_format": metadata.get("config_format", "unknown"),
                                 }
                             )
                     except Exception as e:
@@ -158,7 +200,7 @@ class BackupManager:
                     shutil.copy2(backup_file, target_file)
                     logger.debug(f"Restored: {rel_path}")
 
-            logger.info("✅ Backup restored successfully")
+            logger.info("Backup restored successfully")
             return True
 
         except Exception as e:
@@ -213,6 +255,9 @@ class BackupManager:
         - .claude/ (entire directory)
         - .moai/ (entire directory)
         - CLAUDE.md (file)
+        - .mcp.json (MCP server configuration) (v2.0.0)
+        - .lsp.json (LSP server configuration) (v2.0.0)
+        - .git-hooks/ (custom git hooks) (v2.0.0)
 
         Args:
             description: Description of this backup (default: "pre-update-backup")
@@ -232,6 +277,11 @@ class BackupManager:
             (self.project_root / ".claude", True),  # (path, is_directory)
             (self.project_root / ".moai", True),
             (self.project_root / "CLAUDE.md", False),
+            # MCP/LSP configuration (v2.0.0)
+            (self.project_root / ".mcp.json", False),  # MCP server configuration
+            (self.project_root / ".lsp.json", False),  # LSP server configuration
+            # Git hooks (v2.0.0)
+            (self.project_root / ".git-hooks", True),  # Custom git hooks
         ]
 
         backed_up_items = []
@@ -273,5 +323,5 @@ class BackupManager:
         with open(metadata_path, "w", encoding="utf-8") as f:
             json.dump(metadata, f, indent=2, ensure_ascii=False)
 
-        logger.info(f"✅ Full project backup created successfully: {backup_dir}")
+        logger.info(f"Full project backup created successfully: {backup_dir}")
         return backup_dir

moai_adk/core/migration/file_migrator.py

@@ -3,13 +3,21 @@ File migration module for MoAI-ADK version upgrades
 
 Handles the actual file movement and directory creation
 during migration processes.
+
+Supports migration between:
+- Legacy config.json (.moai/config.json) - pre-v0.24.0
+- Intermediate config.json (.moai/config/config.json) - v0.24.0
+- Section YAML files (.moai/config/sections/*.yaml) - v0.36.0+
 """
 
+import json
 import logging
 import shutil
 from pathlib import Path
 from typing import Any, Dict, List
 
+import yaml
+
 logger = logging.getLogger(__name__)
 
 
@@ -111,10 +119,26 @@ class FileMigrator:
         # Safety check for safe mode
         if safe:
             safe_patterns = [
+                # Legacy and intermediate config.json
                 ".moai/config.json",
+                ".moai/config/config.json",
+                # Statusline configs
                 ".claude/statusline-config.yaml",
+                ".moai/config/statusline-config.yaml",
+                # Section YAML files (v0.36.0+)
+                ".moai/config/sections/user.yaml",
+                ".moai/config/sections/language.yaml",
+                ".moai/config/sections/project.yaml",
+                ".moai/config/sections/git-strategy.yaml",
+                ".moai/config/sections/quality.yaml",
+                ".moai/config/sections/system.yaml",
             ]
-            is_safe = any(str(file_path.relative_to(self.project_root)).endswith(pattern) for pattern in safe_patterns)
+            try:
+                rel_path = str(file_path.relative_to(self.project_root))
+                is_safe = any(rel_path.endswith(pattern) for pattern in safe_patterns)
+            except ValueError:
+                is_safe = False
+
             if not is_safe:
                 logger.warning(f"Refusing to delete non-safe file: {file_path}")
                 return False
@@ -132,7 +156,7 @@ class FileMigrator:
         Execute a migration plan
 
         Args:
-            plan: Migration plan dictionary with 'create', 'move', 'cleanup' keys
+            plan: Migration plan dictionary with 'create', 'move', 'convert', 'cleanup' keys
 
         Returns:
             Dictionary with execution results
@@ -141,6 +165,7 @@ class FileMigrator:
             "success": True,
             "created_dirs": 0,
             "moved_files": 0,
+            "converted_files": 0,
             "cleaned_files": 0,
             "errors": [],
         }
@@ -166,8 +191,155 @@ class FileMigrator:
                 results["errors"].append(f"Failed to move: {move_op['from']} → {move_op['to']}")
                 results["success"] = False
 
+        # Convert config.json to section YAML files (v0.36.0+ migration)
+        for convert_op in plan.get("convert", []):
+            source = self.project_root / convert_op["from"]
+            target_dir = self.project_root / convert_op["to_dir"]
+
+            if self.convert_json_to_section_yaml(source, target_dir):
+                results["converted_files"] += 1
+                logger.info(f"✅ {convert_op['description']}: {convert_op['from']} → {convert_op['to_dir']}/")
+            else:
+                results["errors"].append(f"Failed to convert: {convert_op['from']} → {convert_op['to_dir']}/")
+                results["success"] = False
+
         return results
 
+    def convert_json_to_section_yaml(self, source_json: Path, target_dir: Path) -> bool:
+        """
+        Convert a config.json file to section YAML files
+
+        Args:
+            source_json: Path to the source config.json file
+            target_dir: Path to the target sections directory
+
+        Returns:
+            True if conversion was successful
+        """
+        if not source_json.exists():
+            logger.warning(f"Source JSON file not found: {source_json}")
+            return False
+
+        try:
+            # Read the source JSON
+            with open(source_json, "r", encoding="utf-8") as f:
+                config_data = json.load(f)
+
+            # Ensure target directory exists
+            target_dir.mkdir(parents=True, exist_ok=True)
+
+            # Map JSON keys to section files
+            section_mapping = self._get_section_mapping(config_data)
+
+            # Write each section to its YAML file
+            for section_name, section_data in section_mapping.items():
+                if section_data:
+                    yaml_file = target_dir / f"{section_name}.yaml"
+                    # Skip if file already exists (don't overwrite)
+                    if yaml_file.exists():
+                        logger.debug(f"Section file already exists, skipping: {yaml_file}")
+                        continue
+
+                    with open(yaml_file, "w", encoding="utf-8") as f:
+                        # Add header comment
+                        f.write(f"# {section_name.replace('-', ' ').title()} Settings\n")
+                        f.write("# Migrated from config.json\n\n")
+                        yaml.dump(section_data, f, default_flow_style=False, allow_unicode=True)
+                    logger.debug(f"Created section file: {yaml_file}")
+
+            logger.info(f"Successfully converted {source_json} to section YAML files")
+            return True
+
+        except Exception as e:
+            logger.error(f"Failed to convert {source_json} to section YAML: {e}")
+            return False
+
+    def _get_section_mapping(self, config_data: Dict[str, Any]) -> Dict[str, Dict[str, Any]]:
+        """
+        Map config.json data to section YAML structure
+
+        Args:
+            config_data: The config.json data as a dictionary
+
+        Returns:
+            Dictionary mapping section names to their data
+        """
+        sections: Dict[str, Dict[str, Any]] = {
+            "user": {},
+            "language": {},
+            "project": {},
+            "git-strategy": {},
+            "quality": {},
+            "system": {},
+        }
+
+        # Map user settings
+        if "user_name" in config_data:
+            sections["user"]["user"] = {"name": config_data["user_name"]}
+        if "user" in config_data:
+            sections["user"]["user"] = config_data["user"]
+
+        # Map language settings
+        language_keys = ["conversation_language", "agent_prompt_language", "documentation_language", "code_comments"]
+        language_data = {}
+        for key in language_keys:
+            if key in config_data:
+                language_data[key] = config_data[key]
+        if "language" in config_data:
+            language_data.update(config_data["language"])
+        if language_data:
+            sections["language"]["language"] = language_data
+
+        # Map project settings
+        project_keys = ["project_name", "project_type", "project_description", "locale", "created_at", "initialized"]
+        project_data = {}
+        for key in project_keys:
+            if key in config_data:
+                # Normalize key names
+                normalized_key = key.replace("project_", "")
+                project_data[normalized_key] = config_data[key]
+        if "project" in config_data:
+            project_data.update(config_data["project"])
+        if project_data:
+            sections["project"]["project"] = project_data
+
+        # Map git strategy settings
+        git_keys = ["git_strategy", "auto_branch", "branch_prefix", "commit_style"]
+        git_data = {}
+        for key in git_keys:
+            if key in config_data:
+                git_data[key] = config_data[key]
+        if "git" in config_data:
+            git_data.update(config_data["git"])
+        if git_data:
+            sections["git-strategy"]["git"] = git_data
+
+        # Map quality settings
+        quality_keys = ["tdd_enabled", "test_framework", "coverage_threshold"]
+        quality_data = {}
+        for key in quality_keys:
+            if key in config_data:
+                quality_data[key] = config_data[key]
+        if "quality" in config_data:
+            quality_data.update(config_data["quality"])
+        if "tdd" in config_data:
+            quality_data["tdd"] = config_data["tdd"]
+        if quality_data:
+            sections["quality"]["quality"] = quality_data
+
+        # Map system settings
+        system_data: Dict[str, Any] = {}
+        if "moai_version" in config_data:
+            system_data["moai"] = {"version": config_data["moai_version"]}
+        if "moai" in config_data:
+            system_data["moai"] = config_data["moai"]
+        if "github" in config_data:
+            system_data["github"] = config_data["github"]
+        if system_data:
+            sections["system"] = system_data
+
+        return sections
+
     def cleanup_old_files(self, cleanup_list: List[str], dry_run: bool = False) -> int:
         """
         Clean up old files after successful migration

moai_adk/core/migration/interactive_checkbox_ui.py

@@ -4,7 +4,7 @@ This module provides an enhanced interactive CLI interface with checkbox-style s
 arrow key navigation, and proper element preservation during updates.
 
 Key Features:
-- Arrow key navigation (↑↓) to move between elements
+- Arrow key navigation to move between elements
 - Spacebar to toggle selection with [x] checkbox markers
 - Category grouping (Agents, Commands, Skills, Hooks)
 - Preserve unselected elements (fixes disappearing issue)
@@ -55,13 +55,13 @@ class InteractiveCheckboxUI:
         flattened_elements = self._flatten_elements(elements_by_category)
 
         if not flattened_elements:
-            print("\n✅ No custom elements found in project.")
+            print("\n[OK] No custom elements found in project.")
             print("   All elements are part of the official MoAI-ADK template.")
             return None
 
         if not backup_available:
-            print("\n⚠️ No backup available. Cannot restore custom elements.")
-            print("💡 Run 'moai-adk update' without --force to create a backup first.")
+            print("\n[WARNING] No backup available. Cannot restore custom elements.")
+            print("[TIP] Run 'moai-adk update' without --force to create a backup first.")
             return None
 
         # Launch curses interface
@@ -69,16 +69,16 @@ class InteractiveCheckboxUI:
             selected_indices = self._run_curses_interface(flattened_elements, elements_by_category)
         except ImportError:
             # Curses not available, use enhanced fallback immediately
-            print("\n📱 Terminal doesn't support interactive mode, using enhanced selection...")
+            print("\n[INFO] Terminal doesn't support interactive mode, using enhanced selection...")
             return self._fallback_selection(flattened_elements)
         except Exception as e:
             # Fallback to simple selection if curses fails
-            print(f"\n⚠️ Interactive mode failed: {e}")
+            print(f"\n[WARNING] Interactive mode failed: {e}")
             print("Falling back to enhanced selection mode...")
             return self._fallback_selection(flattened_elements)
 
         if selected_indices is None:
-            print("\n⚠️ Selection cancelled.")
+            print("\n[WARNING] Selection cancelled.")
             return None
 
         # Convert indices to element paths
@@ -88,7 +88,7 @@ class InteractiveCheckboxUI:
                 selected_paths.append(flattened_elements[idx]["path"])
 
         if not selected_paths:
-            print("\n⚠️ No elements selected for restoration.")
+            print("\n[WARNING] No elements selected for restoration.")
             return None
 
         return selected_paths
@@ -180,14 +180,20 @@ class InteractiveCheckboxUI:
         """
 
         def interface(stdscr):
-            # Initialize curses
+            # Initialize curses with adaptive colors
             curses.curs_set(0)  # Hide cursor
-            curses.init_pair(1, curses.COLOR_BLACK, curses.COLOR_WHITE)  # Selected
-            curses.init_pair(2, curses.COLOR_WHITE, curses.COLOR_BLUE)  # Header
-            curses.init_pair(3, curses.COLOR_GREEN, curses.COLOR_BLACK)  # Success
-            curses.init_pair(4, curses.COLOR_YELLOW, curses.COLOR_BLACK)  # Warning
 
-            stdscr.clear()
+            # Enable default terminal colors (transparent background)
+            curses.use_default_colors()
+
+            # Color pairs using -1 for transparent/default background
+            curses.init_pair(1, curses.COLOR_CYAN, -1)  # Current selection (highlighted)
+            curses.init_pair(2, curses.COLOR_YELLOW, -1)  # Category headers
+            curses.init_pair(3, curses.COLOR_GREEN, -1)  # Checked items / Success
+            curses.init_pair(4, curses.COLOR_RED, -1)  # Warnings / Errors
+            curses.init_pair(5, curses.COLOR_MAGENTA, -1)  # Special emphasis
+
+            stdscr.erase()  # Use erase() instead of clear() to preserve background
             stdscr.refresh()
 
             # Main input loop
@@ -224,20 +230,20 @@ class InteractiveCheckboxUI:
             elements: Flattened list of elements and headers
             elements_by_category: Categorized elements for reference
         """
-        stdscr.clear()
+        stdscr.erase()  # Use erase() instead of clear() to preserve background
         h, w = stdscr.getmaxyx()
 
         # Title
-        title = "🔍 Custom Elements Restoration"
+        title = "[SEARCH] Custom Elements Restoration"
         stdscr.addstr(1, (w - len(title)) // 2, title, curses.A_BOLD)
 
         # Instructions
-        instructions = ["↑↓ Navigate | Space Toggle | A:All N:None | Enter:Confirm | Q/ESC:Cancel"]
+        instructions = ["Up/Down Navigate | Space Toggle | A:All N:None | Enter:Confirm | Q/ESC:Cancel"]
         for i, instruction in enumerate(instructions):
             stdscr.addstr(3, 2, instruction)
 
         # Separator
-        stdscr.addstr(4, 0, "─" * w)
+        stdscr.addstr(4, 0, "-" * w)
 
         # Display elements with checkboxes
         y_offset = 6
@@ -247,7 +253,7 @@ class InteractiveCheckboxUI:
 
             if element["type"] == "header":
                 # Category header
-                header_text = f"📁 {element['text']}"
+                header_text = f"[FOLDER] {element['text']}"
                 stdscr.addstr(y_offset, 2, header_text, curses.color_pair(2) | curses.A_BOLD)
                 y_offset += 1
             else:
@@ -261,8 +267,13 @@ class InteractiveCheckboxUI:
                 line = f"{checkbox} {display_name}"
 
                 if is_current:
+                    # Current selection: cyan color with bold
                     stdscr.addstr(y_offset, 4, line, curses.color_pair(1) | curses.A_BOLD)
+                elif is_selected:
+                    # Selected but not current: green color
+                    stdscr.addstr(y_offset, 4, line, curses.color_pair(3))
                 else:
+                    # Not selected: default color
                     stdscr.addstr(y_offset, 4, line)
 
                 y_offset += 1
@@ -356,14 +367,14 @@ class InteractiveCheckboxUI:
         h, w = stdscr.getmaxyx()
 
         # Clear screen for confirmation
-        stdscr.clear()
+        stdscr.erase()  # Use erase() instead of clear() to preserve background
         stdscr.addstr(1, (w - 20) // 2, "Confirm Selection", curses.A_BOLD)
         stdscr.addstr(3, 2, f"Selected {len(selected_paths)} elements:")
 
         for i, path in enumerate(selected_paths[:10]):  # Show max 10 items
             if i >= h - 8:
                 break
-            stdscr.addstr(5 + i, 4, f"• {path}")
+            stdscr.addstr(5 + i, 4, f"* {path}")
 
         if len(selected_paths) > 10:
             stdscr.addstr(h - 4, 4, f"... and {len(selected_paths) - 10} more")
@@ -384,7 +395,7 @@ class InteractiveCheckboxUI:
             List of selected paths or None if cancelled
         """
         print("\n" + "=" * 60)
-        print("🔍 Custom Elements Detected (Simple Mode)")
+        print("[SEARCH] Custom Elements Detected (Simple Mode)")
         print("=" * 60)
         print("These elements are not part of the official MoAI-ADK template:")
         print()
@@ -393,15 +404,15 @@ class InteractiveCheckboxUI:
         for i, element in enumerate(element_list, 1):
             print(f"  {i:2d}. [{element['category']}] {element['name']}")
 
-        print("\n💡 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")
+        print("\n[TIP] 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")
 
         try:
             user_input = input("\nSelect elements to restore: ").strip()
         except (KeyboardInterrupt, EOFError):
-            print("\n⚠️ Selection cancelled.")
+            print("\n[WARNING] Selection cancelled.")
             return None
 
         if not user_input:
@@ -418,9 +429,9 @@ class InteractiveCheckboxUI:
                 if 1 <= idx <= len(element_list):
                     selected_paths.append(element_list[idx - 1]["path"])
                 else:
-                    print(f"⚠️ Invalid number: {idx}")
+                    print(f"[WARNING] Invalid number: {idx}")
         except ValueError:
-            print("⚠️ Invalid input. Please enter numbers separated by commas.")
+            print("[WARNING] Invalid input. Please enter numbers separated by commas.")
             return None
 
         return selected_paths if selected_paths else None
@@ -434,7 +445,7 @@ class InteractiveCheckboxUI:
         Returns:
             True if user confirms, False otherwise
         """
-        print("\n📋 Selection Summary:")
+        print("\n[LIST] Selection Summary:")
         print("-" * 40)
 
         for i, element_path in enumerate(selected_elements, 1):
@@ -449,7 +460,7 @@ class InteractiveCheckboxUI:
             confirm = input("\nConfirm restoration? (y/N): ").strip().lower()
             return confirm in ["y", "yes"]
         except (KeyboardInterrupt, EOFError):
-            print("\n⚠️ Restoration cancelled.")
+            print("\n[WARNING] Restoration cancelled.")
             return False
 
     def _get_element_type(self, element_path: str) -> str: