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

moai_adk/core/template/config.py

@@ -1,45 +1,78 @@
-# @CODE:PY314-001 | SPEC: SPEC-PY314-001.md | TEST: tests/unit/test_config_manager.py
-"""Configuration Manager
+"""Configuration Manager (Migrated to Unified Config)
 
-Manage .moai/config.json:
+DEPRECATED: This module is maintained for backward compatibility.
+New code should use: moai_adk.core.config.unified.UnifiedConfigManager
+
+Manage .moai/config/config.json:
 - Read and write configuration files
 - Support deep merges
 - Preserve UTF-8 content
 - Create directories automatically
+
+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()
 """
 
 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.json."""
+    """
+    Read and write .moai/config/config.json.
+
+    DEPRECATED: Use moai_adk.core.config.unified.UnifiedConfigManager instead.
+    This class is now a thin wrapper around UnifiedConfigManager for backward compatibility.
+    """
 
-    DEFAULT_CONFIG = {
-        "mode": "personal",
-        "locale": "ko",
-        "moai": {
-            "version": "0.3.0"
-        }
-    }
+    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()
 
@@ -48,32 +81,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.
+        """
+        Recursively deep-merge dictionaries.
 
         Args:
             base: Base dictionary.
@@ -83,37 +130,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
                 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/languages.py

@@ -1,4 +1,3 @@
-# @CODE:CORE-PROJECT-001 | SPEC: SPEC-CORE-PROJECT-001/spec.md | TEST: tests/unit/test_language_mapping.py
 """Template mapping by language.
 
 Defines template paths for 20 programming languages.

moai_adk/core/template/merger.py

@@ -1,4 +1,3 @@
-# @CODE:TEMPLATE-001 | SPEC: SPEC-INIT-003/spec.md | Chain: TEMPLATE-001
 """Template file merger (SPEC-INIT-003 v0.3.0).
 
 Intelligently merges existing user files with new templates.
@@ -15,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.
@@ -85,9 +88,7 @@ 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")
 
@@ -104,7 +105,7 @@ class TemplateMerger:
         Returns:
             Merged configuration dictionary.
         """
-        config_path = self.target_path / ".moai" / "config.json"
+        config_path = self.target_path / ".moai" / "config" / "config.json"
 
         # Load existing config if present
         existing_config: dict[str, Any] = {}
@@ -114,14 +115,10 @@ class TemplateMerger:
 
         # Build new config while preferring existing values
         new_config: dict[str, str] = {
-            "projectName": existing_config.get(
-                "projectName", self.target_path.name
-            ),
+            "projectName": existing_config.get("projectName", self.target_path.name),
             "mode": existing_config.get("mode", "personal"),
             "locale": existing_config.get("locale", "ko"),
-            "language": existing_config.get(
-                "language", detected_language or "generic"
-            ),
+            "language": existing_config.get("language", detected_language or "generic"),
         }
 
         return new_config
@@ -166,19 +163,71 @@ class TemplateMerger:
         user_ask = set(user_data.get("permissions", {}).get("ask", []))
         merged_ask = sorted(template_ask | user_ask)
 
-        # Build final merged settings
-        merged = {
-            "env": merged_env,
-            "hooks": template_data.get("hooks", {}),  # Template priority
-            "permissions": {
-                "defaultMode": template_data.get("permissions", {}).get("defaultMode", "default"),
-                "allow": merged_allow,
-                "ask": merged_ask,
-                "deny": merged_deny
-            }
+        # Start with full template (include all fields from template)
+        merged = template_data.copy()
+
+        # Override with merged values
+        merged["env"] = merged_env
+        merged["permissions"] = {
+            "defaultMode": template_data.get("permissions", {}).get("defaultMode", "default"),
+            "allow": merged_allow,
+            "ask": merged_ask,
+            "deny": merged_deny,
         }
 
-        existing_path.write_text(
-            json.dumps(merged, indent=2, ensure_ascii=False) + "\n",
-            encoding="utf-8"
-        )
+        # Preserve user customizations for specific fields (if exist in backup/existing)
+        preserve_fields = ["outputStyle", "spinnerTipsEnabled"]
+        for field in preserve_fields:
+            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")
+
+    def merge_github_workflows(self, template_dir: Path, existing_dir: Path) -> None:
+        """Smart merge for .github/workflows/ directory.
+
+        Rules:
+        - Preserve existing user workflows (never delete)
+        - Add/update only MoAI-ADK managed workflows (moai-*.yml)
+        - Copy other template directories (ISSUE_TEMPLATE/, PULL_REQUEST_TEMPLATE.md)
+
+        Args:
+            template_dir: Template .github directory.
+            existing_dir: Existing .github directory.
+        """
+        import shutil
+
+        # Ensure workflows directory exists
+        workflows_dir = existing_dir / "workflows"
+        workflows_dir.mkdir(exist_ok=True)
+
+        # Track existing user workflows for preservation
+        user_workflows = set()
+        if workflows_dir.exists():
+            for workflow_file in workflows_dir.glob("*.yml"):
+                user_workflows.add(workflow_file.name)
+
+        # Copy template contents with smart merge for workflows
+        for item in template_dir.rglob("*"):
+            if item.is_file():
+                rel_path = item.relative_to(template_dir)
+                dst_item = existing_dir / rel_path
+
+                # Handle workflow files specially
+                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)
+                        shutil.copy2(item, dst_item)
+                    # Skip non-moai workflows to preserve user custom workflows
+                    continue
+
+                # Copy non-workflow files normally
+                dst_item.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(item, dst_item)
+
+            elif item.is_dir():
+                # Create directories as needed
+                rel_path = item.relative_to(template_dir)
+                dst_item = existing_dir / rel_path
+                dst_item.mkdir(parents=True, exist_ok=True)