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

moai_adk/core/template/backup.py

@@ -1,4 +1,3 @@
-# @CODE:TEMPLATE-001 | SPEC: SPEC-INIT-003/spec.md | Chain: TEMPLATE-001
 """Template backup manager (SPEC-INIT-003 v0.3.0).
 
 Creates and manages backups to protect user data during template updates.
@@ -6,17 +5,23 @@ Creates and manages backups to protect user data during template updates.
 
 from __future__ import annotations
 
+import json
+import re
 import shutil
+from datetime import datetime
 from pathlib import Path
 
 
 class TemplateBackup:
     """Create and manage template backups."""
 
-    # Paths excluded from backups (protect user data)
+    # Paths excluded from backups (protect user data) - MUST match TemplateProcessor.PROTECTED_PATHS
+    # Note: These are relative paths within .moai/ directory
     BACKUP_EXCLUDE_DIRS = [
         "specs",  # User SPEC documents
         "reports",  # User reports
+        "project",  # User project documents (product/structure/tech.md)
+        "config/sections",  # User configuration section files (YAML)
     ]
 
     def __init__(self, target_path: Path) -> None:
@@ -42,29 +47,31 @@ class TemplateBackup:
         Returns:
             True when any tracked file exists.
         """
-        return any(
-            (self.target_path / item).exists()
-            for item in [".moai", ".claude", ".github", "CLAUDE.md"]
-        )
+        tracked_items = [".moai", ".claude", ".github", "CLAUDE.md", ".mcp.json", ".lsp.json", ".git-hooks"]
+        return any((self.target_path / item).exists() for item in tracked_items)
 
     def create_backup(self) -> Path:
-        """Create a single backup (always at .moai-backups/backup/).
+        """Create a timestamped backup under .moai-backups/.
 
-        Existing backups are overwritten to maintain only one backup copy.
+        Creates a new timestamped backup directory for each update.
+        Maintains backward compatibility by supporting both new and legacy structures.
+        Creates backup_metadata.json for backup tracking and restoration.
 
         Returns:
-            Backup path (always .moai-backups/backup/).
+            Path to timestamped backup directory (e.g., .moai-backups/20241201_143022/).
         """
-        backup_path = self.target_path / ".moai-backups" / "backup"
-
-        # Remove existing backup if present
-        if backup_path.exists():
-            shutil.rmtree(backup_path)
+        # Generate timestamp for backup directory name
+        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+        backup_path = self.target_path / ".moai-backups" / timestamp
 
         backup_path.mkdir(parents=True, exist_ok=True)
 
+        # Track backed up items for metadata
+        backed_up_items: list[str] = []
+        excluded_items: list[str] = []
+
         # Copy backup targets
-        for item in [".moai", ".claude", ".github", "CLAUDE.md"]:
+        for item in [".moai", ".claude", ".github", "CLAUDE.md", ".mcp.json", ".lsp.json", ".git-hooks"]:
             src = self.target_path / item
             if not src.exists():
                 continue
@@ -73,32 +80,128 @@ class TemplateBackup:
 
             if item == ".moai":
                 # Copy while skipping protected paths
-                self._copy_exclude_protected(src, dst)
+                excluded = self._copy_exclude_protected(src, dst)
+                backed_up_items.append(item)
+                excluded_items.extend(excluded)
             elif src.is_dir():
                 shutil.copytree(src, dst, dirs_exist_ok=True)
+                backed_up_items.append(item)
             else:
                 shutil.copy2(src, dst)
+                backed_up_items.append(item)
+
+        # Create backup metadata
+        metadata = {
+            "timestamp": timestamp,
+            "description": "template_backup",
+            "backed_up_items": backed_up_items,
+            "excluded_items": excluded_items,
+            "excluded_dirs": self.BACKUP_EXCLUDE_DIRS,
+            "project_root": str(self.target_path),
+            "backup_type": "template",
+        }
+
+        metadata_path = backup_path / "backup_metadata.json"
+        with open(metadata_path, "w", encoding="utf-8") as f:
+            json.dump(metadata, f, indent=2, ensure_ascii=False)
 
         return backup_path
 
-    def _copy_exclude_protected(self, src: Path, dst: Path) -> None:
+    def get_latest_backup(self) -> Path | None:
+        """Get the most recent backup, supporting both new and legacy structures.
+
+        Searches for backups in order of preference:
+        1. Latest timestamped backup (new structure)
+        2. Legacy backup/ directory (old structure)
+
+        Returns:
+            Path to the most recent backup directory, or None if no backups exist.
+        """
+        # Check for new timestamped backups first
+        backup_dir = self.target_path / ".moai-backups"
+        if backup_dir.exists():
+            # Match pattern: YYYYMMDD_HHMMSS (8 digits + underscore + 6 digits)
+            timestamp_pattern = re.compile(r"^\d{8}_\d{6}$")
+            timestamped_backups = [d for d in backup_dir.iterdir() if d.is_dir() and timestamp_pattern.match(d.name)]
+
+            if timestamped_backups:
+                # Sort by name (timestamp) and return the latest
+                latest_backup = max(timestamped_backups, key=lambda x: x.name)
+                return latest_backup
+
+        # Fall back to legacy backup/ directory
+        legacy_backup = backup_dir / "backup"
+        if legacy_backup.exists():
+            return legacy_backup
+
+        return None
+
+    def list_backups(self) -> list[Path]:
+        """List all timestamped backup directories.
+
+        Returns:
+            List of backup directory paths, sorted by timestamp (newest first).
+        """
+        backups: list[Path] = []
+        backup_dir = self.target_path / ".moai-backups"
+
+        if not backup_dir.exists():
+            return backups
+
+        # Match pattern: YYYYMMDD_HHMMSS (8 digits + underscore + 6 digits)
+        timestamp_pattern = re.compile(r"^\d{8}_\d{6}$")
+        timestamped_backups = [d for d in backup_dir.iterdir() if d.is_dir() and timestamp_pattern.match(d.name)]
+
+        # Sort by name (timestamp) in descending order (newest first)
+        backups = sorted(timestamped_backups, key=lambda x: x.name, reverse=True)
+        return backups
+
+    def cleanup_old_backups(self, keep_count: int = 5) -> int:
+        """Clean up old backups, keeping only the most recent ones.
+
+        Args:
+            keep_count: Number of recent backups to keep (default: 5).
+
+        Returns:
+            Number of backups deleted.
+        """
+        backups = self.list_backups()
+
+        if len(backups) <= keep_count:
+            return 0
+
+        deleted_count = 0
+        for backup_path in backups[keep_count:]:
+            try:
+                shutil.rmtree(backup_path)
+                deleted_count += 1
+            except Exception:
+                # Ignore deletion errors and continue with other backups
+                pass
+
+        return deleted_count
+
+    def _copy_exclude_protected(self, src: Path, dst: Path) -> list[str]:
         """Copy backup content while excluding protected paths.
 
         Args:
             src: Source directory.
             dst: Destination directory.
+
+        Returns:
+            List of excluded relative paths.
         """
         dst.mkdir(parents=True, exist_ok=True)
 
+        excluded: list[str] = []
+
         for item in src.rglob("*"):
             rel_path = item.relative_to(src)
             rel_path_str = str(rel_path)
 
             # Skip excluded paths
-            if any(
-                rel_path_str.startswith(exclude_dir)
-                for exclude_dir in self.BACKUP_EXCLUDE_DIRS
-            ):
+            if any(rel_path_str.startswith(exclude_dir) for exclude_dir in self.BACKUP_EXCLUDE_DIRS):
+                excluded.append(rel_path_str)
                 continue
 
             dst_item = dst / rel_path
@@ -107,3 +210,47 @@ class TemplateBackup:
                 shutil.copy2(item, dst_item)
             elif item.is_dir():
                 dst_item.mkdir(parents=True, exist_ok=True)
+
+        return excluded
+
+    def restore_backup(self, backup_path: Path | None = None) -> None:
+        """Restore project files from backup.
+
+        Restores .moai, .claude, .github directories and CLAUDE.md file
+        from a backup created by create_backup().
+        Supports both new timestamped and legacy backup structures.
+
+        Args:
+            backup_path: Backup path to restore from.
+                        If None, automatically finds the latest backup.
+
+        Raises:
+            FileNotFoundError: When no backup is found.
+        """
+        if backup_path is None:
+            backup_path = self.get_latest_backup()
+
+        if backup_path is None or not backup_path.exists():
+            raise FileNotFoundError(f"Backup not found: {backup_path}")
+
+        # Restore each item from backup
+        for item in [".moai", ".claude", ".github", "CLAUDE.md", ".mcp.json", ".lsp.json", ".git-hooks"]:
+            src = backup_path / item
+            dst = self.target_path / item
+
+            # Skip if not in backup
+            if not src.exists():
+                continue
+
+            # Remove current version
+            if dst.exists():
+                if dst.is_dir():
+                    shutil.rmtree(dst)
+                else:
+                    dst.unlink()
+
+            # Restore from backup
+            if src.is_dir():
+                shutil.copytree(src, dst, dirs_exist_ok=True)
+            else:
+                shutil.copy2(src, dst)

moai_adk/core/template/config.py

@@ -1,45 +1,102 @@
-# @CODE:PY314-001 | SPEC: SPEC-PY314-001.md | TEST: tests/unit/test_config_manager.py
-"""Configuration Manager
-
-Manage .moai/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.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.
 
-    DEFAULT_CONFIG = {
-        "mode": "personal",
-        "locale": "ko",
-        "moai": {
-            "version": "0.3.0"
-        }
-    }
+    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()
 
@@ -48,32 +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.
+        """
+        Recursively deep-merge dictionaries.
 
         Args:
             base: Base dictionary.
@@ -83,37 +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
                 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.