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

moai_adk/core/migration/version_detector.py

@@ -8,7 +8,9 @@ which migrations are needed.
 import json
 import logging
 from pathlib import Path
-from typing import Any, Dict
+from typing import Any, Dict, Optional
+
+import yaml
 
 logger = logging.getLogger(__name__)
 
@@ -24,26 +26,79 @@ class VersionDetector:
             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"
-        self.new_config = self.project_root / ".moai" / "config" / "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+", "unknown")
+            Version string (e.g., "0.23.0", "0.24.0+", "0.36.0+", "unknown")
         """
-        # Check if already migrated to v0.24.0+
-        if self.new_config.exists():
-            return "0.24.0+"
+        # 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
+        # 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") as f:
+                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:
@@ -67,10 +122,16 @@ class VersionDetector:
             logger.info("Unknown version, assuming no migration needed")
             return False
 
-        if version == "0.24.0+":
-            logger.info("Project already on v0.24.0+")
+        # 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
 
@@ -83,24 +144,46 @@ class VersionDetector:
             {
                 "move": [{"from": "...", "to": "..."}],
                 "create": ["directory1", "directory2"],
-                "cleanup": ["old_file1", "old_file2"]
+                "cleanup": ["old_file1", "old_file2"],
+                "convert": [{"from": "...", "to_dir": "...", "description": "..."}]
             }
         """
-        plan: Dict[str, Any] = {"move": [], "create": [], "cleanup": []}
+        plan: Dict[str, Any] = {"move": [], "create": [], "cleanup": [], "convert": []}
 
         if not self.needs_migration():
             return plan
 
-        # Create config directory
-        plan["create"].append(str(self.project_root / ".moai" / "config"))
+        # Create config directory structure
+        config_dir = self.project_root / ".moai" / "config"
+        plan["create"].append(str(config_dir))
 
-        # Move config.json
-        if self.old_config.exists() and not self.new_config.exists():
+        # 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.new_config.relative_to(self.project_root)),
-                    "description": "Main configuration file",
+                    "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",
                 }
             )
 
@@ -119,6 +202,9 @@ class VersionDetector:
             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
 
@@ -133,7 +219,25 @@ class VersionDetector:
             "detected_version": self.detect_version(),
             "needs_migration": self.needs_migration(),
             "has_old_config": self.old_config.exists(),
-            "has_new_config": self.new_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"

moai_adk/core/migration/version_migrator.py

@@ -3,12 +3,20 @@ Main version migration orchestrator for MoAI-ADK
 
 Coordinates version detection, backup creation, file migration,
 and cleanup processes for automatic project upgrades.
+
+Supports migration from:
+- 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
 from pathlib import Path
 from typing import Any, Dict
 
+import yaml
+
 from .backup_manager import BackupManager
 from .file_migrator import FileMigrator
 from .version_detector import VersionDetector
@@ -165,6 +173,13 @@ class VersionMigrator:
             print(f"   • {move_op['description']}")
             print(f"     {move_op['from']} → {move_op['to']}")
 
+        # Show conversion operations (config.json to section YAML)
+        if plan.get("convert"):
+            print("\n🔄 Files to convert:")
+            for convert_op in plan.get("convert", []):
+                print(f"   • {convert_op['description']}")
+                print(f"     {convert_op['from']} → {convert_op['to_dir']}/")
+
         print("\n🗑️  Files to cleanup after migration:")
         for cleanup_file in plan.get("cleanup", []):
             print(f"   - {cleanup_file}")
@@ -176,20 +191,40 @@ class VersionMigrator:
         Returns:
             True if verification passed
         """
-        # Check that new config exists
-        new_config = self.project_root / ".moai" / "config" / "config.json"
-        if not new_config.exists():
-            logger.error("Verification failed: new config.json not found")
-            return False
-
-        # Check that new config directory exists
+        # Check that config directory exists
         config_dir = self.project_root / ".moai" / "config"
         if not config_dir.is_dir():
             logger.error("Verification failed: config directory not found")
             return False
 
-        logger.debug("All verification checks passed")
-        return True
+        # Check for section YAML format (preferred v0.36.0+)
+        sections_dir = self.project_root / ".moai" / "config" / "sections"
+        system_yaml = sections_dir / "system.yaml"
+
+        if sections_dir.exists() and system_yaml.exists():
+            # Verify system.yaml is valid
+            try:
+                with open(system_yaml, "r", encoding="utf-8") as f:
+                    data = yaml.safe_load(f)
+                    if data and "moai" in data:
+                        logger.debug("Section YAML format verification passed")
+                        return True
+            except Exception as e:
+                logger.warning(f"Failed to verify system.yaml: {e}")
+
+        # Fallback: check for intermediate config.json (v0.24.0 format)
+        intermediate_config = self.project_root / ".moai" / "config" / "config.json"
+        if intermediate_config.exists():
+            try:
+                with open(intermediate_config, "r", encoding="utf-8") as f:
+                    json.load(f)
+                    logger.debug("Intermediate config.json verification passed")
+                    return True
+            except Exception as e:
+                logger.warning(f"Failed to verify config.json: {e}")
+
+        logger.error("Verification failed: no valid configuration found")
+        return False
 
     def check_status(self) -> Dict[str, Any]:
         """

moai_adk/core/model_allocator.py

@@ -0,0 +1,241 @@
+"""Model allocation based on pricing plan.
+
+Assigns appropriate models (opus/sonnet/haiku) to agents based on
+the user's selected service and pricing plan.
+"""
+
+from typing import TypedDict
+
+
+class ModelAllocation(TypedDict):
+    """Model allocation for different agent types."""
+
+    # High-complexity agents (reasoning, architecture)
+    plan: str
+    expert_security: str
+    expert_refactoring: str
+    manager_strategy: str
+
+    # Medium-complexity agents (implementation)
+    expert_backend: str
+    expert_frontend: str
+    expert_database: str
+    manager_tdd: str
+    manager_spec: str
+    manager_docs: str
+    manager_quality: str
+
+    # Low-complexity agents (exploration, quick tasks)
+    explore: str
+    expert_debug: str
+    general_purpose: str
+
+
+# Claude subscription model allocations by pricing plan
+CLAUDE_SUBSCRIPTION_ALLOCATIONS: dict[str, ModelAllocation] = {
+    # Pro ($20/mo) - sonnet-focused, limited opus
+    "pro": {
+        # High-complexity: sonnet (opus limited)
+        "plan": "sonnet",
+        "expert_security": "sonnet",
+        "expert_refactoring": "sonnet",
+        "manager_strategy": "sonnet",
+        # Medium-complexity: sonnet
+        "expert_backend": "sonnet",
+        "expert_frontend": "sonnet",
+        "expert_database": "sonnet",
+        "manager_tdd": "sonnet",
+        "manager_spec": "sonnet",
+        "manager_docs": "sonnet",
+        "manager_quality": "sonnet",
+        # Low-complexity: haiku for speed
+        "explore": "haiku",
+        "expert_debug": "haiku",
+        "general_purpose": "sonnet",
+    },
+    # Max5 ($100/mo) - opus for complex, sonnet for standard
+    "max5": {
+        # High-complexity: opus
+        "plan": "opus",
+        "expert_security": "opus",
+        "expert_refactoring": "opus",
+        "manager_strategy": "opus",
+        # Medium-complexity: sonnet
+        "expert_backend": "sonnet",
+        "expert_frontend": "sonnet",
+        "expert_database": "sonnet",
+        "manager_tdd": "sonnet",
+        "manager_spec": "sonnet",
+        "manager_docs": "sonnet",
+        "manager_quality": "sonnet",
+        # Low-complexity: haiku for speed
+        "explore": "haiku",
+        "expert_debug": "haiku",
+        "general_purpose": "sonnet",
+    },
+    # Max20 ($200/mo) - opus freely available
+    "max20": {
+        # High-complexity: opus
+        "plan": "opus",
+        "expert_security": "opus",
+        "expert_refactoring": "opus",
+        "manager_strategy": "opus",
+        # Medium-complexity: opus or sonnet based on preference
+        "expert_backend": "opus",
+        "expert_frontend": "opus",
+        "expert_database": "opus",
+        "manager_tdd": "opus",
+        "manager_spec": "opus",
+        "manager_docs": "sonnet",  # Docs don't need opus
+        "manager_quality": "opus",
+        # Low-complexity: haiku for speed
+        "explore": "haiku",
+        "expert_debug": "sonnet",
+        "general_purpose": "opus",
+    },
+}
+
+# Claude API model allocations (same as subscription)
+CLAUDE_API_ALLOCATIONS = CLAUDE_SUBSCRIPTION_ALLOCATIONS.copy()
+
+# GLM CodePlan model allocations
+GLM_ALLOCATIONS: dict[str, ModelAllocation] = {
+    # Basic - equivalent to sonnet
+    "basic": {
+        "plan": "glm-basic",
+        "expert_security": "glm-basic",
+        "expert_refactoring": "glm-basic",
+        "manager_strategy": "glm-basic",
+        "expert_backend": "glm-basic",
+        "expert_frontend": "glm-basic",
+        "expert_database": "glm-basic",
+        "manager_tdd": "glm-basic",
+        "manager_spec": "glm-basic",
+        "manager_docs": "glm-basic",
+        "manager_quality": "glm-basic",
+        "explore": "glm-basic",
+        "expert_debug": "glm-basic",
+        "general_purpose": "glm-basic",
+    },
+    # Pro - equivalent to sonnet~opus
+    "glm_pro": {
+        "plan": "glm-pro",
+        "expert_security": "glm-pro",
+        "expert_refactoring": "glm-pro",
+        "manager_strategy": "glm-pro",
+        "expert_backend": "glm-pro",
+        "expert_frontend": "glm-pro",
+        "expert_database": "glm-pro",
+        "manager_tdd": "glm-pro",
+        "manager_spec": "glm-pro",
+        "manager_docs": "glm-basic",
+        "manager_quality": "glm-pro",
+        "explore": "glm-basic",
+        "expert_debug": "glm-basic",
+        "general_purpose": "glm-pro",
+    },
+    # Enterprise - equivalent to opus
+    "enterprise": {
+        "plan": "glm-enterprise",
+        "expert_security": "glm-enterprise",
+        "expert_refactoring": "glm-enterprise",
+        "manager_strategy": "glm-enterprise",
+        "expert_backend": "glm-enterprise",
+        "expert_frontend": "glm-enterprise",
+        "expert_database": "glm-enterprise",
+        "manager_tdd": "glm-enterprise",
+        "manager_spec": "glm-enterprise",
+        "manager_docs": "glm-pro",
+        "manager_quality": "glm-enterprise",
+        "explore": "glm-basic",
+        "expert_debug": "glm-pro",
+        "general_purpose": "glm-enterprise",
+    },
+}
+
+
+def get_model_allocation(
+    service_type: str,
+    pricing_plan: str | None = None,
+) -> ModelAllocation:
+    """Get model allocation based on service type and pricing plan.
+
+    Args:
+        service_type: Service type (claude_subscription, claude_api, glm, hybrid)
+        pricing_plan: Pricing plan (pro, max5, max20, basic, glm_pro, enterprise)
+
+    Returns:
+        ModelAllocation dictionary mapping agent types to model names
+    """
+    if service_type == "claude_subscription":
+        plan = pricing_plan or "pro"
+        return CLAUDE_SUBSCRIPTION_ALLOCATIONS.get(plan, CLAUDE_SUBSCRIPTION_ALLOCATIONS["pro"])
+
+    if service_type == "claude_api":
+        plan = pricing_plan or "pro"
+        return CLAUDE_API_ALLOCATIONS.get(plan, CLAUDE_API_ALLOCATIONS["pro"])
+
+    if service_type == "glm":
+        plan = pricing_plan or "basic"
+        return GLM_ALLOCATIONS.get(plan, GLM_ALLOCATIONS["basic"])
+
+    if service_type == "hybrid":
+        # Hybrid uses Claude allocation with GLM fallback for simple tasks
+        plan = pricing_plan or "pro"
+        base = CLAUDE_SUBSCRIPTION_ALLOCATIONS.get(plan, CLAUDE_SUBSCRIPTION_ALLOCATIONS["pro"])
+        # Override exploration agents to use GLM for cost optimization
+        return {
+            **base,
+            "explore": "glm-basic",
+            "expert_debug": "glm-basic",
+        }
+
+    # Default fallback
+    return CLAUDE_SUBSCRIPTION_ALLOCATIONS["pro"]
+
+
+def get_agent_model(
+    agent_name: str,
+    service_type: str,
+    pricing_plan: str | None = None,
+) -> str:
+    """Get the model for a specific agent.
+
+    Args:
+        agent_name: Agent name (e.g., "Plan", "expert-backend", "Explore")
+        service_type: Service type
+        pricing_plan: Pricing plan
+
+    Returns:
+        Model name (opus, sonnet, haiku, or glm-*)
+    """
+    allocation = get_model_allocation(service_type, pricing_plan)
+
+    # Normalize agent name to key format
+    key = agent_name.lower().replace("-", "_")
+
+    # Try direct lookup
+    value = allocation.get(key)
+    if isinstance(value, str):
+        return value
+
+    # Try category-based lookup
+    if key.startswith("expert_"):
+        return allocation.get("expert_backend", "sonnet")
+    if key.startswith("manager_"):
+        return allocation.get("manager_tdd", "sonnet")
+    if key.startswith("builder_"):
+        return allocation.get("general_purpose", "sonnet")
+
+    # Default to sonnet
+    return "sonnet"
+
+
+__all__ = [
+    "ModelAllocation",
+    "get_model_allocation",
+    "get_agent_model",
+    "CLAUDE_SUBSCRIPTION_ALLOCATIONS",
+    "CLAUDE_API_ALLOCATIONS",
+    "GLM_ALLOCATIONS",
+]

moai_adk/core/project/backup_utils.py

@@ -8,19 +8,29 @@ Selective backup strategy:
 from pathlib import Path
 
 # Backup targets (OR condition - back up when any exist)
+# Note: Both YAML and JSON config files are checked for backward compatibility
 BACKUP_TARGETS = [
-    ".moai/config/config.json",
+    ".moai/config/config.yaml",
+    ".moai/config/config.json",  # Legacy support
+    ".moai/config/sections/",  # Section-based config files
     ".moai/project/",
     ".moai/memory/",
     ".claude/",
     ".github/",
     "CLAUDE.md",
+    # MCP/LSP configuration (v2.0.0)
+    ".mcp.json",  # MCP server configuration
+    ".lsp.json",  # LSP server configuration
+    # Git hooks (v2.0.0)
+    ".git-hooks/",  # Custom git hooks
 ]
 
-# User data protection paths (excluded from backups)
+# User data protection paths (excluded from backups) - MUST match TemplateProcessor.PROTECTED_PATHS
 PROTECTED_PATHS = [
     ".moai/specs/",
     ".moai/reports/",
+    ".moai/project/",
+    ".moai/config/sections/",
 ]