moai-adk 0.35.1__py3-none-any.whl

moai_adk/core/template/config.py

@@ -0,0 +1,191 @@
+"""Configuration Manager (Migrated to Unified Config)
+
+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/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"}}
+
+    def __init__(self, config_path: Path) -> None:
+        """
+        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.
+
+        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()
+
+        with open(self.config_path, encoding="utf-8") as f:
+            data: dict[str, Any] = json.load(f)
+            return data
+
+    def save(self, config: dict[str, Any]) -> None:
+        """
+        Persist the configuration file.
+
+        Creates directories when missing and preserves UTF-8 content.
+
+        Args:
+            config: Configuration dictionary to save.
+        """
+        # Use unified config if available
+        if self._unified_config:
+            self._unified_config.update(config, deep_merge=False)
+            self._unified_config.save(backup=True)
+            return
+
+        # 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.
+
+        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.
+
+        Args:
+            base: Base dictionary.
+            updates: Dictionary with updates.
+
+        Returns:
+            Merged dictionary.
+        """
+        result = base.copy()
+        for key, value in updates.items():
+            if key in result and isinstance(result[key], dict) and isinstance(value, dict):
+                result[key] = self._deep_merge(result[key], value)
+            else:
+                result[key] = value
+        return result
+
+    @staticmethod
+    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 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
+            ... )
+        """
+        # 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
+
+        # 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

@@ -0,0 +1,43 @@
+"""Template mapping by language.
+
+Defines template paths for 20 programming languages.
+"""
+
+LANGUAGE_TEMPLATES: dict[str, str] = {
+    "python": ".moai/project/tech/python.md.j2",
+    "typescript": ".moai/project/tech/typescript.md.j2",
+    "javascript": ".moai/project/tech/javascript.md.j2",
+    "java": ".moai/project/tech/java.md.j2",
+    "go": ".moai/project/tech/go.md.j2",
+    "rust": ".moai/project/tech/rust.md.j2",
+    "dart": ".moai/project/tech/dart.md.j2",
+    "swift": ".moai/project/tech/swift.md.j2",
+    "kotlin": ".moai/project/tech/kotlin.md.j2",
+    "csharp": ".moai/project/tech/csharp.md.j2",
+    "php": ".moai/project/tech/php.md.j2",
+    "ruby": ".moai/project/tech/ruby.md.j2",
+    "elixir": ".moai/project/tech/elixir.md.j2",
+    "scala": ".moai/project/tech/scala.md.j2",
+    "clojure": ".moai/project/tech/clojure.md.j2",
+    "haskell": ".moai/project/tech/haskell.md.j2",
+    "c": ".moai/project/tech/c.md.j2",
+    "cpp": ".moai/project/tech/cpp.md.j2",
+    "lua": ".moai/project/tech/lua.md.j2",
+    "ocaml": ".moai/project/tech/ocaml.md.j2",
+}
+
+
+def get_language_template(language: str) -> str:
+    """Return the template path for a language (case-insensitive).
+
+    Args:
+        language: Language name (case-insensitive).
+
+    Returns:
+        Template path; defaults to default.md.j2 for unknown languages.
+    """
+    if not language:
+        return ".moai/project/tech/default.md.j2"
+
+    language_lower = language.lower()
+    return LANGUAGE_TEMPLATES.get(language_lower, ".moai/project/tech/default.md.j2")

moai_adk/core/template/merger.py

@@ -0,0 +1,233 @@
+"""Template file merger (SPEC-INIT-003 v0.3.0).
+
+Intelligently merges existing user files with new templates.
+"""
+
+from __future__ import annotations
+
+import json
+import shutil
+from pathlib import Path
+from typing import Any
+
+
+class TemplateMerger:
+    """Encapsulate template merging logic."""
+
+    PROJECT_INFO_HEADERS = (
+        "## Project Information",
+        "## Project Information",  # Keep for backward compatibility
+        "## Project Info",
+    )
+
+    def __init__(self, target_path: Path) -> None:
+        """Initialize the merger.
+
+        Args:
+            target_path: Project path (absolute).
+        """
+        self.target_path = target_path.resolve()
+
+    def merge_claude_md(self, template_path: Path, existing_path: Path) -> None:
+        """Smart merge for CLAUDE.md.
+
+        Rules:
+        - Use the latest template structure/content.
+        - Preserve the existing "## Project Information" section.
+
+        Args:
+            template_path: Template CLAUDE.md.
+            existing_path: Existing CLAUDE.md.
+        """
+        # Extract the existing project information section
+        existing_content = existing_path.read_text(encoding="utf-8")
+        project_info_start, _ = self._find_project_info_section(existing_content)
+        project_info = ""
+        if project_info_start != -1:
+            # Extract until EOF
+            project_info = existing_content[project_info_start:]
+
+        # Load template content
+        template_content = template_path.read_text(encoding="utf-8")
+
+        # 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)
+            if template_project_start != -1:
+                template_content = template_content[:template_project_start].rstrip()
+
+            # Merge template content with the preserved section
+            merged_content = f"{template_content}\n\n{project_info}"
+            existing_path.write_text(merged_content, encoding="utf-8")
+        else:
+            # No project info; copy the template as-is
+            shutil.copy2(template_path, existing_path)
+
+    def _find_project_info_section(self, content: str) -> tuple[int, str | None]:
+        """Find the project information header in the given content."""
+        for header in self.PROJECT_INFO_HEADERS:
+            index = content.find(header)
+            if index != -1:
+                return index, header
+        return -1, None
+
+    def merge_gitignore(self, template_path: Path, existing_path: Path) -> None:
+        """.gitignore merge.
+
+        Rules:
+        - Keep existing entries.
+        - Add new entries from the template.
+        - Remove duplicates.
+
+        Args:
+            template_path: Template .gitignore file.
+            existing_path: Existing .gitignore file.
+        """
+        template_lines = set(template_path.read_text(encoding="utf-8").splitlines())
+        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]
+
+        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.
+
+        Rules:
+        - Prefer existing settings.
+        - Use detected language plus defaults for new projects.
+
+        Args:
+            detected_language: Detected language.
+
+        Returns:
+            Merged configuration dictionary.
+        """
+        config_path = self.target_path / ".moai" / "config" / "config.json"
+
+        # Load existing config if present
+        existing_config: dict[str, Any] = {}
+        if config_path.exists():
+            with open(config_path, encoding="utf-8") as f:
+                existing_config = json.load(f)
+
+        # Build new config while preferring existing values
+        new_config: dict[str, str] = {
+            "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"),
+        }
+
+        return new_config
+
+    def merge_settings_json(self, template_path: Path, existing_path: Path, backup_path: Path | None = None) -> None:
+        """Smart merge for .claude/settings.json.
+
+        Rules:
+        - env: shallow merge (user variables preserved)
+        - permissions.allow: array merge (deduplicated)
+        - permissions.deny: template priority (security)
+        - hooks: template priority
+
+        Args:
+            template_path: Template settings.json.
+            existing_path: Existing settings.json.
+            backup_path: Backup settings.json (optional, for user settings extraction).
+        """
+        # Load template
+        template_data = json.loads(template_path.read_text(encoding="utf-8"))
+
+        # Load backup or existing for user settings
+        user_data: dict[str, Any] = {}
+        if backup_path and backup_path.exists():
+            user_data = json.loads(backup_path.read_text(encoding="utf-8"))
+        elif existing_path.exists():
+            user_data = json.loads(existing_path.read_text(encoding="utf-8"))
+
+        # Merge env (shallow merge, user variables preserved)
+        merged_env = {**template_data.get("env", {}), **user_data.get("env", {})}
+
+        # Merge permissions.allow (deduplicated array merge)
+        template_allow = set(template_data.get("permissions", {}).get("allow", []))
+        user_allow = set(user_data.get("permissions", {}).get("allow", []))
+        merged_allow = sorted(template_allow | user_allow)
+
+        # permissions.deny: template priority (security)
+        merged_deny = template_data.get("permissions", {}).get("deny", [])
+
+        # permissions.ask: template priority + user additions
+        template_ask = set(template_data.get("permissions", {}).get("ask", []))
+        user_ask = set(user_data.get("permissions", {}).get("ask", []))
+        merged_ask = sorted(template_ask | user_ask)
+
+        # 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,
+        }
+
+        # 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)