moai-adk 0.3.0__py3-none-any.whl

moai_adk/core/template/languages.py

@@ -0,0 +1,44 @@
+# @CODE:CORE-PROJECT-001 | SPEC: SPEC-CORE-PROJECT-001.md | TEST: tests/unit/test_language_mapping.py
+"""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,117 @@
+# @CODE:TEMPLATE-001 | SPEC: SPEC-INIT-003.md | Chain: TEMPLATE-001
+"""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."""
+
+    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 "## 프로젝트 정보" section.
+
+        Args:
+            template_path: Template CLAUDE.md.
+            existing_path: Existing CLAUDE.md.
+        """
+        # Extract the existing "## 프로젝트 정보" section
+        existing_content = existing_path.read_text(encoding="utf-8")
+        project_info_start = existing_content.find("## 프로젝트 정보")
+        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 = template_content.find("## 프로젝트 정보")
+            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 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.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

moai_adk/core/template/processor.py

@@ -0,0 +1,310 @@
+# @CODE:TEMPLATE-001 | SPEC: SPEC-INIT-003.md | Chain: TEMPLATE-001
+"""Template copy and backup processor (SPEC-INIT-003 v0.3.0: preserve user content)."""
+
+from __future__ import annotations
+
+import shutil
+from pathlib import Path
+
+from rich.console import Console
+
+from moai_adk.core.template.backup import TemplateBackup
+from moai_adk.core.template.merger import TemplateMerger
+
+console = Console()
+
+
+class TemplateProcessor:
+    """Orchestrate template copying and backups."""
+
+    # User data protection paths (never touch) - SPEC-INIT-003 v0.3.0
+    PROTECTED_PATHS = [
+        ".moai/specs/",  # User SPEC documents
+        ".moai/reports/",  # User reports
+        ".moai/project/",  # User project documents (product/structure/tech.md)
+        ".moai/config.json",  # User configuration (merged via /alfred:9-update flow)
+    ]
+
+    # Paths excluded from backups
+    BACKUP_EXCLUDE = PROTECTED_PATHS
+
+    def __init__(self, target_path: Path) -> None:
+        """Initialize the processor.
+
+        Args:
+            target_path: Project path.
+        """
+        self.target_path = target_path.resolve()
+        self.template_root = self._get_template_root()
+        self.backup = TemplateBackup(self.target_path)
+        self.merger = TemplateMerger(self.target_path)
+
+    def _get_template_root(self) -> Path:
+        """Return the template root path."""
+        # src/moai_adk/core/template/processor.py → src/moai_adk/templates/
+        current_file = Path(__file__).resolve()
+        package_root = current_file.parent.parent.parent
+        return package_root / "templates"
+
+    def copy_templates(self, backup: bool = True, silent: bool = False) -> None:
+        """Copy template files into the project.
+
+        Args:
+            backup: Whether to create a backup.
+            silent: Reduce log output when True.
+        """
+        # 1. Create a backup when existing files are present
+        if backup and self._has_existing_files():
+            backup_path = self.create_backup()
+            if not silent:
+                console.print(f"💾 Backup created: {backup_path.name}")
+
+        # 2. Copy templates
+        if not silent:
+            console.print("📄 Copying templates...")
+
+        self._copy_claude(silent)
+        self._copy_moai(silent)
+        self._copy_claude_md(silent)
+        self._copy_gitignore(silent)
+
+        if not silent:
+            console.print("✅ Templates copied successfully")
+
+    def _has_existing_files(self) -> bool:
+        """Determine whether project files exist (backup decision helper)."""
+        return self.backup.has_existing_files()
+
+    def create_backup(self) -> Path:
+        """Create a timestamped backup (delegated)."""
+        return self.backup.create_backup()
+
+    def _copy_exclude_protected(self, src: Path, dst: Path) -> None:
+        """Copy content while excluding protected paths.
+
+        Args:
+            src: Source directory.
+            dst: Destination directory.
+        """
+        dst.mkdir(parents=True, exist_ok=True)
+
+        # PROTECTED_PATHS: only specs/ and reports/ are excluded during copying
+        # project/ and config.json are preserved only when they already exist
+        template_protected_paths = [
+            "specs",
+            "reports",
+        ]
+
+        for item in src.rglob("*"):
+            rel_path = item.relative_to(src)
+            rel_path_str = str(rel_path)
+
+            # Skip template copy for specs/ and reports/
+            if any(rel_path_str.startswith(p) for p in template_protected_paths):
+                continue
+
+            dst_item = dst / rel_path
+            if item.is_file():
+                # Preserve user content by skipping existing files (v0.3.0)
+                # This automatically protects project/ and config.json
+                if dst_item.exists():
+                    continue
+                dst_item.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(item, dst_item)
+            elif item.is_dir():
+                dst_item.mkdir(parents=True, exist_ok=True)
+
+    def _copy_claude(self, silent: bool = False) -> None:
+        """.claude/ directory copy (selective with alfred folder overwrite).
+
+        Strategy:
+        - Alfred folders (commands/agents/hooks/output-styles/alfred) → copy wholesale (delete & overwrite)
+          * Creates individual backup before deletion for safety
+        - Other files/folders → copy individually (preserve existing)
+        """
+        src = self.template_root / ".claude"
+        dst = self.target_path / ".claude"
+
+        if not src.exists():
+            if not silent:
+                console.print("⚠️ .claude/ template not found")
+            return
+
+        # Create .claude directory if not exists
+        dst.mkdir(parents=True, exist_ok=True)
+
+        # Alfred folders to copy wholesale (overwrite)
+        alfred_folders = [
+            "hooks/alfred",
+            "commands/alfred",
+            "output-styles/alfred",
+            "agents/alfred",
+        ]
+
+        # 1. Copy Alfred folders wholesale (backup before delete & overwrite)
+        for folder in alfred_folders:
+            src_folder = src / folder
+            dst_folder = dst / folder
+
+            if src_folder.exists():
+                # Backup this folder before deletion (safety measure)
+                if dst_folder.exists():
+                    self._backup_alfred_folder(dst_folder, folder)
+                    shutil.rmtree(dst_folder)
+
+                # Create parent directory if needed
+                dst_folder.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copytree(src_folder, dst_folder)
+                if not silent:
+                    console.print(f"   ✅ .claude/{folder}/ overwritten")
+
+        # 2. Copy other files/folders individually (preserve existing)
+        for item in src.iterdir():
+            rel_path = item.relative_to(src)
+            dst_item = dst / rel_path
+
+            # Skip Alfred parent folders (already handled above)
+            if item.is_dir() and item.name in ["hooks", "commands", "output-styles", "agents"]:
+                continue
+
+            if item.is_file():
+                # Copy file, skip if exists (preserve user modifications)
+                if not dst_item.exists():
+                    shutil.copy2(item, dst_item)
+            elif item.is_dir():
+                # Copy directory recursively (preserve existing files)
+                if not dst_item.exists():
+                    shutil.copytree(item, dst_item)
+
+        if not silent:
+            console.print("   ✅ .claude/ copy complete (alfred folders overwritten, others preserved)")
+
+    def _backup_alfred_folder(self, folder_path: Path, folder_name: str) -> None:
+        """Backup an Alfred folder before overwriting (safety measure).
+
+        Args:
+            folder_path: Path to the folder to backup.
+            folder_name: Name of the folder (e.g., "hooks/alfred").
+        """
+        if not folder_path.exists():
+            return
+
+        # Create backup directory in .moai-backups/.claude-backups/{timestamp}/
+        backup_base = self.target_path / ".moai-backups" / ".claude-backups"
+        backup_base.mkdir(parents=True, exist_ok=True)
+
+        # Generate timestamp-based backup directory
+        from moai_adk.core.project.backup_utils import generate_backup_dir_name
+
+        timestamp = generate_backup_dir_name()
+        backup_dir = backup_base / timestamp
+
+        # Backup this specific folder
+        backup_folder = backup_dir / folder_name
+        backup_folder.parent.mkdir(parents=True, exist_ok=True)
+        shutil.copytree(folder_path, backup_folder)
+
+    def _copy_moai(self, silent: bool = False) -> None:
+        """.moai/ directory copy (excludes protected paths)."""
+        src = self.template_root / ".moai"
+        dst = self.target_path / ".moai"
+
+        if not src.exists():
+            if not silent:
+                console.print("⚠️ .moai/ template not found")
+            return
+
+        # Paths excluded from template copying (specs/, reports/)
+        template_protected_paths = [
+            "specs",
+            "reports",
+        ]
+
+        # Copy while skipping protected paths
+        for item in src.rglob("*"):
+            rel_path = item.relative_to(src)
+            rel_path_str = str(rel_path)
+
+            # Skip specs/ and reports/
+            if any(rel_path_str.startswith(p) for p in template_protected_paths):
+                continue
+
+            dst_item = dst / rel_path
+            if item.is_file():
+                # Skip existing files to preserve user content (v0.3.0)
+                if dst_item.exists():
+                    continue
+                dst_item.parent.mkdir(parents=True, exist_ok=True)
+                shutil.copy2(item, dst_item)
+            elif item.is_dir():
+                dst_item.mkdir(parents=True, exist_ok=True)
+
+        if not silent:
+            console.print("   ✅ .moai/ copy complete (user content preserved)")
+
+    def _copy_claude_md(self, silent: bool = False) -> None:
+        """Copy CLAUDE.md with smart merging."""
+        src = self.template_root / "CLAUDE.md"
+        dst = self.target_path / "CLAUDE.md"
+
+        if not src.exists():
+            if not silent:
+                console.print("⚠️ CLAUDE.md template not found")
+            return
+
+        # Preserve project information when the file exists
+        if dst.exists():
+            self._merge_claude_md(src, dst)
+            if not silent:
+                console.print("   🔄 CLAUDE.md merged (project information preserved)")
+        else:
+            shutil.copy2(src, dst)
+            if not silent:
+                console.print("   ✅ CLAUDE.md copy complete")
+
+    def _merge_claude_md(self, src: Path, dst: Path) -> None:
+        """Delegate the smart merge for CLAUDE.md.
+
+        Args:
+            src: Template CLAUDE.md.
+            dst: Project CLAUDE.md.
+        """
+        self.merger.merge_claude_md(src, dst)
+
+    def _copy_gitignore(self, silent: bool = False) -> None:
+        """.gitignore copy (optional)."""
+        src = self.template_root / ".gitignore"
+        dst = self.target_path / ".gitignore"
+
+        if not src.exists():
+            return
+
+        # Merge with the existing .gitignore when present
+        if dst.exists():
+            self._merge_gitignore(src, dst)
+            if not silent:
+                console.print("   🔄 .gitignore merged")
+        else:
+            shutil.copy2(src, dst)
+            if not silent:
+                console.print("   ✅ .gitignore copy complete")
+
+    def _merge_gitignore(self, src: Path, dst: Path) -> None:
+        """Delegate the .gitignore merge.
+
+        Args:
+            src: Template .gitignore.
+            dst: Project .gitignore.
+        """
+        self.merger.merge_gitignore(src, dst)
+
+    def merge_config(self, detected_language: str | None = None) -> dict[str, str]:
+        """Delegate the smart merge for config.json.
+
+        Args:
+            detected_language: Detected language.
+
+        Returns:
+            Merged configuration dictionary.
+        """
+        return self.merger.merge_config(detected_language)