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

moai_adk/core/template/config.py

@@ -1,38 +1,102 @@
-"""Configuration Manager
-
-Manage .moai/config/config.json:
-- Read and write configuration files
-- Support deep merges
-- Preserve UTF-8 content
-- Create directories automatically
+"""Configuration Manager (Migrated to Unified Config).
+
+⚠️ DEPRECATED: This module is deprecated and will be removed in a future version.
+
+New code should use: from moai_adk.core.config.unified import UnifiedConfigManager, get_unified_config
+
+Migration Guide:
+    OLD:
+        >>> from moai_adk.core.template.config import ConfigManager
+        >>> config = ConfigManager()
+
+    NEW:
+        >>> from moai_adk.core.config.unified import UnifiedConfigManager
+        >>> config = UnifiedConfigManager()
+        >>> data = config.get_all()
+
+Configuration sources (in priority order):
+    1. Section YAML files: .moai/config/sections/*.yaml (new approach)
+       - language.yaml: Language settings
+       - user.yaml: User settings
+       - project.yaml: Project metadata
+       - system.yaml: MoAI system settings
+       - git-strategy.yaml: Git workflow settings
+       - quality.yaml: Quality and TDD settings
+    2. Monolithic config.yaml: .moai/config/config.yaml (legacy)
+    3. Monolithic config.json: .moai/config/config.json (legacy fallback)
+
+Migration Path:
+    OLD:
+        >>> from moai_adk.core.template.config import ConfigManager
+        >>> config_mgr = ConfigManager(Path(".moai/config/config.json"))
+        >>> data = config_mgr.load()
+
+    NEW:
+        >>> from moai_adk.core.config.unified import get_unified_config
+        >>> config = get_unified_config()
+        >>> data = config.get_all()
+
+Status: Deprecated - Maintained for backward compatibility only
+Removal Target: v10.0.0
+Last Updated: 2026-01-06
 """
 
 import json
 from pathlib import Path
 from typing import Any
 
+# Import unified config manager
+try:
+    from moai_adk.core.config.unified import UnifiedConfigManager, get_unified_config
+
+    UNIFIED_AVAILABLE = True
+except ImportError:
+    UNIFIED_AVAILABLE = False
+
 
 class ConfigManager:
-    """Read and write .moai/config/config.json."""
+    """
+    Read and write MoAI configuration.
+
+    DEPRECATED: Use moai_adk.core.config.unified.UnifiedConfigManager instead.
+    This class is now a thin wrapper around UnifiedConfigManager for backward compatibility.
+
+    Supports both:
+    - New: Section YAML files (.moai/config/sections/*.yaml)
+    - Legacy: Monolithic config.json (.moai/config/config.json)
+    """
 
     DEFAULT_CONFIG = {"mode": "personal", "locale": "ko", "moai": {"version": "0.3.0"}}
 
     def __init__(self, config_path: Path) -> None:
-        """Initialize the ConfigManager.
+        """
+        Initialize the ConfigManager.
 
         Args:
             config_path: Path to config.json.
         """
         self.config_path = config_path
 
+        # Use unified config if available
+        if UNIFIED_AVAILABLE:
+            self._unified_config = UnifiedConfigManager(config_path)
+        else:
+            self._unified_config = None
+
     def load(self) -> dict[str, Any]:
-        """Load the configuration file.
+        """
+        Load the configuration file.
 
         Returns default values when the file is missing.
 
         Returns:
             Configuration dictionary.
         """
+        # Use unified config if available
+        if self._unified_config:
+            return self._unified_config.get_all()
+
+        # Fallback to direct file access
         if not self.config_path.exists():
             return self.DEFAULT_CONFIG.copy()
 
@@ -41,34 +105,46 @@ class ConfigManager:
             return data
 
     def save(self, config: dict[str, Any]) -> None:
-        """Persist the configuration file.
+        """
+        Persist the configuration file.
 
         Creates directories when missing and preserves UTF-8 content.
 
         Args:
             config: Configuration dictionary to save.
         """
-        # Ensure the directory exists
-        self.config_path.parent.mkdir(parents=True, exist_ok=True)
+        # Use unified config if available
+        if self._unified_config:
+            self._unified_config.update(config, deep_merge=False)
+            self._unified_config.save(backup=True)
+            return
 
-        # Write while preserving UTF-8 characters
+        # Fallback to direct file access
+        self.config_path.parent.mkdir(parents=True, exist_ok=True)
         with open(self.config_path, "w", encoding="utf-8") as f:
             json.dump(config, f, ensure_ascii=False, indent=2)
 
     def update(self, updates: dict[str, Any]) -> None:
-        """Update the configuration using a deep merge.
+        """
+        Update the configuration using a deep merge.
 
         Args:
             updates: Dictionary of updates to apply.
         """
+        # Use unified config if available
+        if self._unified_config:
+            self._unified_config.update(updates, deep_merge=True)
+            self._unified_config.save(backup=True)
+            return
+
+        # Fallback to direct implementation
         current = self.load()
         merged = self._deep_merge(current, updates)
         self.save(merged)
 
-    def _deep_merge(
-        self, base: dict[str, Any], updates: dict[str, Any]
-    ) -> dict[str, Any]:
-        """Recursively deep-merge dictionaries.
+    def _deep_merge(self, base: dict[str, Any], updates: dict[str, Any]) -> dict[str, Any]:
+        """
+        Recursively deep-merge dictionaries.
 
         Args:
             base: Base dictionary.
@@ -78,41 +154,62 @@ class ConfigManager:
             Merged dictionary.
         """
         result = base.copy()
-
         for key, value in updates.items():
-            if (
-                key in result
-                and isinstance(result[key], dict)
-                and isinstance(value, dict)
-            ):
-                # When both sides are dicts, merge recursively
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
                 result[key] = self._deep_merge(result[key], value)
             else:
-                # Otherwise, overwrite the value
                 result[key] = value
-
         return result
 
     @staticmethod
-    def set_optimized(config_path: Path, value: bool) -> None:
-        """Set the optimized field in config.json.
+    def set_optimized_field(config_path: Path, field_path: str, value: Any) -> None:
+        """
+        Optimized method for setting a single configuration field.
+
+        Reads only once, modifies in memory, writes atomically with minimal overhead.
+        Used by optimization processes to update fields like project.optimized.
 
         Args:
-            config_path: Path to config.json.
-            value: Value to set (True or False).
+            config_path: Path to config file.
+            field_path: Dot-separated field path (e.g., "project.optimized").
+            value: Value to set.
+
+        Example:
+            >>> ConfigManager.set_optimized_field(
+            ...     Path(".moai/config/config.json"),
+            ...     "project.optimized",
+            ...     True
+            ... )
         """
-        if not config_path.exists():
+        # Use unified config if available
+        if UNIFIED_AVAILABLE:
+            unified_config = get_unified_config(config_path)
+            unified_config.set(field_path, value)
+            unified_config.save(backup=False)  # Skip backup for optimization flag
             return
 
-        try:
-            with open(config_path, encoding="utf-8") as f:
-                config = json.load(f)
-
-            config.setdefault("project", {})["optimized"] = value
-
-            with open(config_path, "w", encoding="utf-8") as f:
-                json.dump(config, f, ensure_ascii=False, indent=2)
-                f.write("\n")  # Add trailing newline
-        except (json.JSONDecodeError, KeyError, OSError):
-            # Ignore errors if config.json is invalid or inaccessible
-            pass
+        # Fallback implementation
+        config_path.parent.mkdir(parents=True, exist_ok=True)
+
+        # Read current config
+        config_dict: dict[str, Any]
+        if config_path.exists():
+            with open(config_path, "r", encoding="utf-8") as f:
+                config_dict = json.load(f)
+        else:
+            config_dict = {}
+
+        # Navigate to target field
+        keys = field_path.split(".")
+        current: dict[str, Any] = config_dict
+        for key in keys[:-1]:
+            if key not in current:
+                current[key] = {}
+            current = current[key]
+
+        # Set value
+        current[keys[-1]] = value
+
+        # Atomic write
+        with open(config_path, "w", encoding="utf-8") as f:
+            json.dump(config_dict, f, ensure_ascii=False, indent=2)

moai_adk/core/template/merger.py

@@ -14,7 +14,11 @@ from typing import Any
 class TemplateMerger:
     """Encapsulate template merging logic."""
 
-    PROJECT_INFO_HEADERS = ("## Project Information", "## 프로젝트 정보")
+    PROJECT_INFO_HEADERS = (
+        "## Project Information",
+        "## Project Information",  # Keep for backward compatibility
+        "## Project Info",
+    )
 
     def __init__(self, target_path: Path) -> None:
         """Initialize the merger.
@@ -49,9 +53,7 @@ class TemplateMerger:
         # Merge when project info exists
         if project_info:
             # Remove the project info section from the template
-            template_project_start, _ = self._find_project_info_section(
-                template_content
-            )
+            template_project_start, _ = self._find_project_info_section(template_content)
             if template_project_start != -1:
                 template_content = template_content[:template_project_start].rstrip()
 
@@ -86,14 +88,16 @@ class TemplateMerger:
         existing_lines = existing_path.read_text(encoding="utf-8").splitlines()
 
         # Merge while removing duplicates
-        merged_lines = existing_lines + [
-            line for line in template_lines if line not in existing_lines
-        ]
+        merged_lines = existing_lines + [line for line in template_lines if line not in existing_lines]
 
         existing_path.write_text("\n".join(merged_lines) + "\n", encoding="utf-8")
 
     def merge_config(self, detected_language: str | None = None) -> dict[str, str]:
-        """Smart merge for config.json.
+        """Smart merge for configuration using section YAML files with JSON fallback.
+
+        Supports both:
+        - New: Section YAML files (.moai/config/sections/*.yaml)
+        - Legacy: Monolithic config.json (.moai/config/config.json)
 
         Rules:
         - Prefer existing settings.
@@ -105,27 +109,47 @@ class TemplateMerger:
         Returns:
             Merged configuration dictionary.
         """
-        config_path = self.target_path / ".moai" / "config" / "config.json"
+        try:
+            import yaml
+
+            yaml_available = True
+        except ImportError:
+            yaml_available = False
 
-        # Load existing config if present
+        # Check for section-based YAML configuration first (new approach)
+        sections_dir = self.target_path / ".moai" / "config" / "sections"
         existing_config: dict[str, Any] = {}
-        if config_path.exists():
-            with open(config_path, encoding="utf-8") as f:
-                existing_config = json.load(f)
+
+        if yaml_available and sections_dir.exists() and sections_dir.is_dir():
+            # Load from section YAML files
+            for section_file in sections_dir.glob("*.yaml"):
+                try:
+                    with open(section_file, "r", encoding="utf-8") as f:
+                        section_data = yaml.safe_load(f) or {}
+                        existing_config.update(section_data)
+                except Exception:
+                    pass  # Skip unreadable section files
+        else:
+            # Fallback to legacy config.json
+            config_path = self.target_path / ".moai" / "config" / "config.json"
+            if config_path.exists():
+                with open(config_path, encoding="utf-8") as f:
+                    existing_config = json.load(f)
+
+        # Extract project-related settings from nested structure
+        project_config = existing_config.get("project", {})
 
         # Build new config while preferring existing values
         new_config: dict[str, str] = {
-            "projectName": existing_config.get("projectName", self.target_path.name),
+            "projectName": project_config.get("name", existing_config.get("projectName", self.target_path.name)),
             "mode": existing_config.get("mode", "personal"),
-            "locale": existing_config.get("locale", "ko"),
+            "locale": project_config.get("locale", existing_config.get("locale", "ko")),
             "language": existing_config.get("language", detected_language or "generic"),
         }
 
         return new_config
 
-    def merge_settings_json(
-        self, template_path: Path, existing_path: Path, backup_path: Path | None = None
-    ) -> None:
+    def merge_settings_json(self, template_path: Path, existing_path: Path, backup_path: Path | None = None) -> None:
         """Smart merge for .claude/settings.json.
 
         Rules:
@@ -171,9 +195,7 @@ class TemplateMerger:
         # Override with merged values
         merged["env"] = merged_env
         merged["permissions"] = {
-            "defaultMode": template_data.get("permissions", {}).get(
-                "defaultMode", "default"
-            ),
+            "defaultMode": template_data.get("permissions", {}).get("defaultMode", "default"),
             "allow": merged_allow,
             "ask": merged_ask,
             "deny": merged_deny,
@@ -185,9 +207,7 @@ class TemplateMerger:
             if field in user_data:
                 merged[field] = user_data[field]
 
-        existing_path.write_text(
-            json.dumps(merged, indent=2, ensure_ascii=False) + "\n", encoding="utf-8"
-        )
+        existing_path.write_text(json.dumps(merged, indent=2, ensure_ascii=False) + "\n", encoding="utf-8")
 
     def merge_github_workflows(self, template_dir: Path, existing_dir: Path) -> None:
         """Smart merge for .github/workflows/ directory.
@@ -220,9 +240,7 @@ class TemplateMerger:
                 dst_item = existing_dir / rel_path
 
                 # Handle workflow files specially
-                if rel_path.parent.name == "workflows" and rel_path.name.endswith(
-                    ".yml"
-                ):
+                if rel_path.parent.name == "workflows" and rel_path.name.endswith(".yml"):
                     # Only update MoAI-ADK managed workflows (moai-*.yml)
                     if rel_path.name.startswith("moai-"):
                         dst_item.parent.mkdir(parents=True, exist_ok=True)