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

moai_adk/core/config/unified.py

@@ -13,13 +13,20 @@ Features:
 - Deep merge for nested configs
 - Configuration migration between versions
 - Domain-specific facades for different subsystems
+- Modular section-based YAML configuration (new in v0.36.0)
 
 Design Philosophy:
-- Single source of truth for `.moai/config/config.yaml` (with JSON fallback)
+- Primary: Modular section files `.moai/config/sections/*.yaml`
+- Fallback: Legacy monolithic `.moai/config/config.yaml` or `config.json`
 - Best patterns from StatuslineConfig, UnifiedConfigManager, ConfigurationManager
 - Backward compatible with existing ConfigManager interfaces
 - Performance optimized with caching and minimal I/O
 
+Configuration Architecture:
+- New projects: Modular sections (language.yaml, user.yaml, project.yaml, etc.)
+- Legacy projects: Monolithic config.json/config.yaml (auto-migrated on update)
+- Priority: Section files override monolithic config if both exist
+
 Usage:
     >>> from moai_adk.core.config.unified import get_unified_config
     >>> config = get_unified_config()
@@ -95,62 +102,59 @@ class UnifiedConfigManager:
         Initialize configuration manager (called once by singleton).
 
         Args:
-            config_path: Optional path to config file
+            config_path: Optional path to config file (legacy mode) or sections directory
         """
         # Set config path with auto-detection
         if config_path:
             self._config_path = Path(config_path)
         else:
-            # Auto-detect YAML (preferred) or JSON (fallback)
+            # Auto-detect configuration strategy
             base_path = Path.cwd() / ".moai" / "config"
-            yaml_path = base_path / "config.yaml"
-            json_path = base_path / "config.json"
+            sections_dir = base_path / "sections"
 
-            if YAML_AVAILABLE and yaml_path.exists():
-                self._config_path = yaml_path
-            elif json_path.exists():
-                self._config_path = json_path
+            # Priority 1: Section-based configuration (new approach)
+            if sections_dir.exists() and sections_dir.is_dir():
+                self._config_path = sections_dir
             else:
-                # Default to YAML for new projects
-                self._config_path = yaml_path if YAML_AVAILABLE else json_path
+                # Priority 2: Monolithic YAML (legacy)
+                yaml_path = base_path / "config.yaml"
+                json_path = base_path / "config.json"
+
+                if YAML_AVAILABLE and yaml_path.exists():
+                    self._config_path = yaml_path
+                elif json_path.exists():
+                    self._config_path = json_path
+                else:
+                    # Default to sections for new projects
+                    self._config_path = sections_dir if YAML_AVAILABLE else yaml_path
 
         # Load configuration
         self._load_config()
 
     def _load_config(self) -> None:
         """
-        Load configuration from file with caching.
+        Load configuration from file or sections with caching.
 
         Implements cache invalidation based on file modification time.
         Falls back to default configuration if file doesn't exist.
-        Supports both YAML (preferred) and JSON (legacy) formats.
+        Supports three modes:
+        1. Section-based YAML (new): Load from .moai/config/sections/*.yaml
+        2. Monolithic YAML (legacy): Load from .moai/config/config.yaml
+        3. Monolithic JSON (legacy): Load from .moai/config/config.json
         """
         try:
-            # Check if file exists
+            # Check if path exists
             if not self._config_path.exists():
-                logger.warning(f"Config file not found: {self._config_path}")
+                logger.warning(f"Config path not found: {self._config_path}")
                 self._config = self._get_default_config()
                 return
 
-            # Check cache validity
-            current_mtime = self._config_path.stat().st_mtime
-            if self._last_modified and current_mtime == self._last_modified:
-                # Cache is still valid
-                return
-
-            # Load from file (auto-detect format)
-            with open(self._config_path, "r", encoding="utf-8") as f:
-                if self._config_path.suffix == ".yaml" or self._config_path.suffix == ".yml":
-                    if not YAML_AVAILABLE:
-                        raise ImportError("PyYAML is required for YAML config files. Install with: pip install pyyaml")
-                    self._config = yaml.safe_load(f) or {}
-                else:
-                    self._config = json.load(f)
-
-            # Update cache timestamp
-            self._last_modified = current_mtime
-
-            logger.debug(f"Loaded config from {self._config_path}")
+            # Section-based configuration (new approach)
+            if self._config_path.is_dir():
+                self._load_from_sections()
+            else:
+                # Monolithic configuration (legacy)
+                self._load_from_monolithic()
 
         except (
             json.JSONDecodeError,
@@ -161,6 +165,69 @@ class UnifiedConfigManager:
             logger.error(f"Failed to load config: {e}")
             self._config = self._get_default_config()
 
+    def _load_from_sections(self) -> None:
+        """
+        Load configuration from modular section YAML files.
+
+        Loads and merges all *.yaml files from sections directory:
+        - sections/language.yaml
+        - sections/user.yaml
+        - sections/project.yaml
+        - sections/system.yaml
+        - sections/git-strategy.yaml
+        - sections/quality.yaml
+        """
+        # Check cache validity (use directory mtime)
+        current_mtime = self._config_path.stat().st_mtime
+        if self._last_modified and current_mtime == self._last_modified:
+            # Cache is still valid
+            return
+
+        if not YAML_AVAILABLE:
+            raise ImportError("PyYAML is required for section-based config. Install with: pip install pyyaml")
+
+        # Merge all section files
+        merged_config: dict[str, Any] = {}
+        section_files = sorted(self._config_path.glob("*.yaml"))
+
+        for section_file in section_files:
+            try:
+                with open(section_file, "r", encoding="utf-8") as f:
+                    section_data = yaml.safe_load(f) or {}
+                    merged_config = self._deep_merge(merged_config, section_data)
+                    logger.debug(f"Loaded section: {section_file.name}")
+            except Exception as e:
+                logger.warning(f"Failed to load section {section_file.name}: {e}")
+
+        self._config = merged_config
+        self._last_modified = current_mtime
+        logger.debug(f"Loaded config from {len(section_files)} section files")
+
+    def _load_from_monolithic(self) -> None:
+        """
+        Load configuration from single monolithic file (legacy).
+
+        Supports both YAML and JSON formats.
+        """
+        # Check cache validity
+        current_mtime = self._config_path.stat().st_mtime
+        if self._last_modified and current_mtime == self._last_modified:
+            # Cache is still valid
+            return
+
+        # Load from file (auto-detect format)
+        with open(self._config_path, "r", encoding="utf-8") as f:
+            if self._config_path.suffix == ".yaml" or self._config_path.suffix == ".yml":
+                if not YAML_AVAILABLE:
+                    raise ImportError("PyYAML is required for YAML config files. Install with: pip install pyyaml")
+                self._config = yaml.safe_load(f) or {}
+            else:
+                self._config = json.load(f)
+
+        # Update cache timestamp
+        self._last_modified = current_mtime
+        logger.debug(f"Loaded config from {self._config_path}")
+
     def get(self, key: str, default: Any = None) -> Any:
         """
         Get configuration value with dot-notation support.
@@ -238,7 +305,7 @@ class UnifiedConfigManager:
 
     def save(self, backup: bool = True) -> bool:
         """
-        Save configuration to file with atomic write.
+        Save configuration to file or sections with atomic write.
 
         Args:
             backup: If True, create backup before saving (default: True)
@@ -247,42 +314,123 @@ class UnifiedConfigManager:
             bool: True if save successful, False otherwise
 
         Pattern: Temp file → Atomic rename (prevents corruption)
+
+        Note: For section-based configs, saves to individual section files.
+              For monolithic configs, saves to single file.
         """
         try:
-            # Create backup if requested
-            if backup and self._config_path.exists():
-                self._create_backup()
+            # Section-based configuration
+            if self._config_path.is_dir():
+                return self._save_to_sections(backup)
+            else:
+                # Monolithic configuration (legacy)
+                return self._save_to_monolithic(backup)
 
-            # Atomic write pattern: temp file → rename
-            temp_path = self._config_path.with_suffix(".tmp")
+        except (OSError, PermissionError) as e:
+            logger.error(f"Failed to save config: {e}")
+            return False
+
+    def _save_to_sections(self, backup: bool) -> bool:
+        """
+        Save configuration to modular section YAML files.
+
+        Args:
+            backup: If True, create backup before saving
+
+        Returns:
+            bool: True if successful
+        """
+        if not YAML_AVAILABLE:
+            raise ImportError("PyYAML is required for section-based config. Install with: pip install pyyaml")
+
+        # Create backup if requested
+        if backup and self._config_path.exists():
+            self._create_backup()
+
+        # Define section mapping (top-level keys to section files)
+        section_mapping = {
+            "language": "language.yaml",
+            "user": "user.yaml",
+            "project": "project.yaml",
+            "moai": "system.yaml",
+            "github": "system.yaml",
+            "git": "git-strategy.yaml",
+            "quality": "quality.yaml",
+            "tdd": "quality.yaml",
+            "hooks": "system.yaml",
+            "session": "system.yaml",
+        }
+
+        # Group config data by section file
+        section_data: Dict[str, Dict[str, Any]] = {}
+        for key, value in self._config.items():
+            section_file = section_mapping.get(key, "system.yaml")
+            if section_file not in section_data:
+                section_data[section_file] = {}
+            section_data[section_file][key] = value
+
+        # Write each section file atomically
+        for section_file, data in section_data.items():
+            section_path = self._config_path / section_file
+            temp_path = section_path.with_suffix(".tmp")
 
-            # Write to temp file (auto-detect format)
             with open(temp_path, "w", encoding="utf-8") as f:
-                if self._config_path.suffix == ".yaml" or self._config_path.suffix == ".yml":
-                    if not YAML_AVAILABLE:
-                        raise ImportError("PyYAML is required for YAML config files. Install with: pip install pyyaml")
-                    yaml.safe_dump(
-                        self._config,
-                        f,
-                        default_flow_style=False,
-                        allow_unicode=True,
-                        sort_keys=False,
-                    )
-                else:
-                    json.dump(self._config, f, indent=2, ensure_ascii=False)
+                yaml.safe_dump(
+                    data,
+                    f,
+                    default_flow_style=False,
+                    allow_unicode=True,
+                    sort_keys=False,
+                )
 
             # Atomic rename
-            temp_path.replace(self._config_path)
+            temp_path.replace(section_path)
 
-            # Update cache timestamp
-            self._last_modified = self._config_path.stat().st_mtime
+        # Update cache timestamp
+        self._last_modified = self._config_path.stat().st_mtime
+        logger.info(f"Saved config to {len(section_data)} section files")
+        return True
 
-            logger.info(f"Saved config to {self._config_path}")
-            return True
+    def _save_to_monolithic(self, backup: bool) -> bool:
+        """
+        Save configuration to single monolithic file (legacy).
 
-        except (OSError, PermissionError) as e:
-            logger.error(f"Failed to save config: {e}")
-            return False
+        Args:
+            backup: If True, create backup before saving
+
+        Returns:
+            bool: True if successful
+        """
+        # Create backup if requested
+        if backup and self._config_path.exists():
+            self._create_backup()
+
+        # Atomic write pattern: temp file → rename
+        temp_path = self._config_path.with_suffix(".tmp")
+
+        # Write to temp file (auto-detect format)
+        with open(temp_path, "w", encoding="utf-8") as f:
+            if self._config_path.suffix == ".yaml" or self._config_path.suffix == ".yml":
+                if not YAML_AVAILABLE:
+                    raise ImportError("PyYAML is required for YAML config files. Install with: pip install pyyaml")
+                yaml.safe_dump(
+                    self._config,
+                    f,
+                    default_flow_style=False,
+                    allow_unicode=True,
+                    sort_keys=False,
+                )
+            else:
+                json.dump(self._config, f, indent=2, ensure_ascii=False)
+
+        # Atomic rename
+        temp_path.replace(self._config_path)
+
+        # Update cache timestamp
+        self._last_modified = self._config_path.stat().st_mtime
+
+        logger.info(f"Saved config to {self._config_path}")
+        return True
 
     def _create_backup(self) -> None:
         """Create timestamped backup of config file."""
@@ -393,8 +541,34 @@ def get_unified_config(
 # Convenience functions for common operations
 @lru_cache(maxsize=1)
 def get_config_path() -> Path:
-    """Get path to configuration file."""
-    return Path.cwd() / ".moai" / "config" / "config.json"
+    """
+    Get path to configuration file or sections directory.
+
+    Returns:
+        Path: Path to sections directory (new) or config file (legacy)
+
+    Note: Prioritizes section-based config over monolithic files.
+          Legacy projects may still use config.json or config.yaml.
+    """
+    base_path = Path.cwd() / ".moai" / "config"
+    sections_dir = base_path / "sections"
+
+    # Priority 1: Section-based configuration (new approach)
+    if sections_dir.exists() and sections_dir.is_dir():
+        return sections_dir
+
+    # Priority 2: Monolithic YAML (legacy)
+    yaml_path = base_path / "config.yaml"
+    if yaml_path.exists():
+        return yaml_path
+
+    # Priority 3: Monolithic JSON (legacy)
+    json_path = base_path / "config.json"
+    if json_path.exists():
+        return json_path
+
+    # Default: Prefer sections for new projects
+    return sections_dir if YAML_AVAILABLE else yaml_path
 
 
 def get_config_value(key: str, default: Any = None) -> Any:

moai_adk/core/error_recovery_system.py

@@ -855,7 +855,11 @@ class ErrorRecoverySystem:
             return False
 
     def _restore_config_backup(self, error_report: ErrorReport, parameters: Dict[str, Any]) -> bool:
-        """Restore configuration from backup"""
+        """Restore configuration from backup.
+
+        Supports both YAML and JSON configuration formats with backward
+        compatibility for legacy JSON-only backups.
+        """
         try:
             logger.info("Restoring configuration from backup...")
 
@@ -864,16 +868,30 @@ class ErrorRecoverySystem:
                 logger.warning("No configuration backup directory found")
                 return False
 
-            # Find most recent backup
-            backup_files = list(backup_dir.glob("config_*.json"))
+            # Find most recent backup - check both YAML and JSON formats
+            yaml_backups = list(backup_dir.glob("config_*.yaml"))
+            json_backups = list(backup_dir.glob("config_*.json"))
+            backup_files = yaml_backups + json_backups
+
             if not backup_files:
                 logger.warning("No configuration backups found")
                 return False
 
             latest_backup = max(backup_files, key=lambda f: f.stat().st_mtime)
+            is_yaml_backup = latest_backup.suffix in (".yaml", ".yml")
+
+            # Determine target config file based on backup format
+            if is_yaml_backup:
+                config_file = self.project_root / ".moai" / "config" / "config.yaml"
+            else:
+                # Legacy JSON backup - check if project uses YAML now
+                yaml_config = self.project_root / ".moai" / "config" / "config.yaml"
+                if yaml_config.exists():
+                    config_file = yaml_config
+                else:
+                    config_file = self.project_root / ".moai" / "config" / "config.json"
 
             # Restore configuration
-            config_file = self.project_root / ".moai" / "config" / "config.json"
             import shutil
 
             shutil.copy2(latest_backup, config_file)

moai_adk/core/git/conflict_detector.py

@@ -42,7 +42,14 @@ class GitConflictDetector:
         "CLAUDE.md",
         ".gitignore",
         ".claude/settings.json",
-        ".moai/config/config.json",
+        ".moai/config/config.json",  # Legacy monolithic config
+        ".moai/config/config.yaml",  # Legacy monolithic config
+        ".moai/config/sections/language.yaml",  # Section-based config
+        ".moai/config/sections/user.yaml",
+        ".moai/config/sections/project.yaml",
+        ".moai/config/sections/system.yaml",
+        ".moai/config/sections/git-strategy.yaml",
+        ".moai/config/sections/quality.yaml",
     }
 
     # Config file patterns that are generally safe
@@ -53,6 +60,8 @@ class GitConflictDetector:
         ".prettierrc",
         "settings.json",
         "config.json",
+        "config.yaml",
+        ".yaml",  # YAML files (includes section files)
         ".md",  # Markdown files
     }
 

moai_adk/core/git/event_detector.py

@@ -13,11 +13,14 @@ class EventDetector:
     CRITICAL_FILES = {
         "CLAUDE.md",
         "config.json",
-        ".moai/config/config.json",
+        "config.yaml",
+        ".moai/config/config.json",  # Legacy monolithic config
+        ".moai/config/config.yaml",  # Legacy monolithic config
     }
 
     CRITICAL_DIRS = {
         ".moai/memory",
+        ".moai/config/sections",  # Section-based config directory
     }
 
     def is_risky_deletion(self, deleted_files: list[str]) -> bool:
@@ -52,7 +55,13 @@ class EventDetector:
         """
         Determine whether the file is critical.
 
-        SPEC requirement: modifying CLAUDE.md, config.json, or .moai/memory/*.md is risky.
+        SPEC requirement: modifying CLAUDE.md, config files, or .moai/memory/*.md is risky.
+
+        Critical files include:
+        - CLAUDE.md
+        - Legacy: config.json, config.yaml, .moai/config/config.{json,yaml}
+        - New: .moai/config/sections/*.yaml
+        - Memory: .moai/memory/*.md
 
         Args:
             file_path: File path to inspect.
@@ -67,11 +76,13 @@ class EventDetector:
         # Convert to string for further checks
         path_str = str(file_path)
 
-        # Detect .moai/config/config.json paths
-        if ".moai/config/config.json" in path_str or ".moai\\config.json" in path_str:
+        # Detect .moai/config/config.{json,yaml} paths (legacy monolithic)
+        if ".moai/config/config.json" in path_str or ".moai\\config\\config.json" in path_str:
+            return True
+        if ".moai/config/config.yaml" in path_str or ".moai\\config\\config.yaml" in path_str:
             return True
 
-        # Detect files inside the .moai/memory/ directory
+        # Detect files inside critical directories (.moai/memory, .moai/config/sections)
         for critical_dir in self.CRITICAL_DIRS:
             if critical_dir in path_str or critical_dir.replace("/", "\\") in path_str:
                 return True

moai_adk/core/language_config_resolver.py

@@ -3,11 +3,17 @@ MoAI-ADK Language Configuration Resolver
 
 Centralized system for resolving language configuration from multiple sources:
 1. Environment variables (highest priority)
-2. Configuration file (.moai/config/config.json)
-3. Default values (fallback)
+2. Section files (.moai/config/sections/language.yaml, user.yaml)
+3. Legacy config file (.moai/config/config.yaml or config.json)
+4. Default values (fallback)
+
+Configuration Architecture:
+- New projects: Use modular section files for better organization
+- Legacy projects: Continue using config.json or config.yaml
+- Section files take priority over monolithic config if both exist
 
 This module provides a unified interface for all language-related configuration
-needs across the MoAI-ADK system.
+needs across the MoAI-ADK system with backward compatibility.
 """
 
 import json
@@ -116,6 +122,93 @@ class LanguageConfigResolver:
         return config
 
     def _load_config_file(self) -> Optional[Dict[str, Any]]:
+        """
+        Load configuration from .moai/config/config.yaml or section files.
+
+        Priority:
+        1. Section files (.moai/config/sections/*.yaml) - highest
+        2. Main config file (.moai/config/config.yaml)
+        3. None if neither exists
+
+        Returns:
+            Configuration dictionary or None if file doesn't exist
+        """
+        config = {}
+
+        # Try loading from section files first (higher priority)
+        section_config = self._load_section_files()
+        if section_config:
+            config.update(section_config)
+
+        # Try loading from main config file (fallback)
+        main_config = self._load_main_config_file()
+        if main_config:
+            # Only update fields not already set by section files
+            for key, value in main_config.items():
+                if key not in config:
+                    config[key] = value
+
+        return config if config else None
+
+    def _load_section_files(self) -> Optional[Dict[str, Any]]:
+        """
+        Load configuration from section files in .moai/config/sections/
+
+        Section files:
+        - user.yaml: User identification
+        - language.yaml: Language preferences
+
+        Returns:
+            Configuration dictionary or None if section files don't exist
+        """
+        if not YAML_AVAILABLE:
+            return None
+
+        sections_dir = self.project_root / ".moai" / "config" / "sections"
+        if not sections_dir.exists():
+            return None
+
+        config = {}
+
+        try:
+            # Load user.yaml
+            user_file = sections_dir / "user.yaml"
+            if user_file.exists():
+                with open(user_file, "r", encoding="utf-8") as f:
+                    user_data = yaml.safe_load(f) or {}
+                    user_config = user_data.get("user", {})
+                    if "name" in user_config:
+                        config["user_name"] = user_config["name"]
+
+            # Load language.yaml
+            language_file = sections_dir / "language.yaml"
+            if language_file.exists():
+                with open(language_file, "r", encoding="utf-8") as f:
+                    lang_data = yaml.safe_load(f) or {}
+                    language_config = lang_data.get("language", {})
+
+                    if "conversation_language" in language_config:
+                        config["conversation_language"] = language_config["conversation_language"]
+                    if "conversation_language_name" in language_config:
+                        config["conversation_language_name"] = language_config["conversation_language_name"]
+                    if "agent_prompt_language" in language_config:
+                        config["agent_prompt_language"] = language_config["agent_prompt_language"]
+                    if "git_commit_messages" in language_config:
+                        config["git_commit_messages"] = language_config["git_commit_messages"]
+                    if "code_comments" in language_config:
+                        config["code_comments"] = language_config["code_comments"]
+                    if "documentation" in language_config:
+                        config["documentation"] = language_config["documentation"]
+                    if "error_messages" in language_config:
+                        config["error_messages"] = language_config["error_messages"]
+
+            return config if config else None
+
+        except (yaml.YAMLError, IOError, KeyError) as e:
+            print(f"Warning: Failed to load section files: {e}")
+            return None
+
+    def _load_main_config_file(self) -> Optional[Dict[str, Any]]:
         """
         Load configuration from .moai/config/config.yaml or config.json file.