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

moai_adk/core/template/backup.py

@@ -5,6 +5,7 @@ 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
@@ -14,10 +15,13 @@ 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:
@@ -43,13 +47,15 @@ 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 timestamped backup under .moai-backups/.
 
         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:
             Path to timestamped backup directory (e.g., .moai-backups/20241201_143022/).
@@ -60,8 +66,12 @@ class TemplateBackup:
 
         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
@@ -70,11 +80,30 @@ 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
 
@@ -107,21 +136,72 @@ class TemplateBackup:
 
         return None
 
-    def _copy_exclude_protected(self, src: Path, dst: Path) -> 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):
+                excluded.append(rel_path_str)
                 continue
 
             dst_item = dst / rel_path
@@ -131,6 +211,8 @@ class TemplateBackup:
             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.
 
@@ -152,7 +234,7 @@ class TemplateBackup:
             raise FileNotFoundError(f"Backup not found: {backup_path}")
 
         # Restore each item from backup
-        for item in [".moai", ".claude", ".github", "CLAUDE.md"]:
+        for item in [".moai", ".claude", ".github", "CLAUDE.md", ".mcp.json", ".lsp.json", ".git-hooks"]:
             src = backup_path / item
             dst = self.target_path / item
 

moai_adk/core/template/config.py

@@ -1,13 +1,29 @@
-"""Configuration Manager (Migrated to Unified Config)
+"""Configuration Manager (Migrated to Unified Config).
 
-DEPRECATED: This module is maintained for backward compatibility.
-New code should use: moai_adk.core.config.unified.UnifiedConfigManager
+⚠️ DEPRECATED: This module is deprecated and will be removed in a future version.
 
-Manage .moai/config/config.json:
-- Read and write configuration files
-- Support deep merges
-- Preserve UTF-8 content
-- Create directories automatically
+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:
@@ -19,6 +35,10 @@ Migration Path:
         >>> 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
@@ -36,10 +56,14 @@ except ImportError:
 
 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"}}

moai_adk/core/template/merger.py

@@ -93,7 +93,11 @@ class TemplateMerger:
         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,19 +109,41 @@ 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"),
         }