moai-adk 0.4.0__py3-none-any.whl → 0.4.4__py3-none-any.whl

moai_adk/__init__.py

@@ -4,12 +4,11 @@
 SPEC-First TDD Framework with Alfred SuperAgent
 """
 
-from importlib.metadata import version, PackageNotFoundError
+from importlib.metadata import PackageNotFoundError, version
 
 try:
     __version__ = version("moai-adk")
 except PackageNotFoundError:
-    # Development mode fallback
-    __version__ = "0.4.0-dev"
+    __version__ = "0.4.1-dev"
 
 __all__ = ["__version__"]

moai_adk/cli/commands/init.py

@@ -66,9 +66,9 @@ def create_progress_callback(progress: Progress, task_ids: Sequence[TaskID]):
 )
 @click.option(
     "--locale",
-    type=click.Choice(["ko", "en", "ja", "zh"]),
-    default="ko",
-    help="Preferred language",
+    type=click.Choice(["ko", "en"]),
+    default=None,
+    help="Preferred language (default: en)",
 )
 @click.option(
     "--language",
@@ -95,13 +95,13 @@ def init(
         path: Project directory path (default: current directory)
         non_interactive: Skip prompts and use defaults
         mode: Project mode (personal/team)
-        locale: Preferred language (ko/en/ja/zh)
+        locale: Preferred language (ko/en). When omitted, defaults to en.
         language: Programming language
         force: Force reinitialize without confirmation
     """
     try:
         # 1. Print banner
-        print_banner()
+        print_banner(__version__)
 
         # 2. Check current directory mode
         is_current_dir = path == "."
@@ -114,6 +114,7 @@ def init(
                 f"\n[cyan]🚀 Initializing project at {project_path}...[/cyan]\n"
             )
             project_name = project_path.name if is_current_dir else path
+            locale = locale or "en"
         else:
             # Interactive Mode
             print_welcome_message()
@@ -123,6 +124,7 @@ def init(
                 project_name=None if is_current_dir else path,
                 is_current_dir=is_current_dir,
                 project_path=project_path,
+                initial_locale=locale,
             )
 
             # Override with prompt answers
@@ -133,6 +135,9 @@ def init(
 
             console.print("\n[cyan]🚀 Starting installation...[/cyan]\n")
 
+            if locale is None:
+                locale = answers["locale"]
+
         # 4. Check for reinitialization (SPEC-INIT-003 v0.3.0) - DEFAULT TO FORCE MODE
         initializer = ProjectInitializer(project_path)
 

moai_adk/cli/commands/update.py

@@ -1,13 +1,17 @@
-"""Update command - Upgrade moai-adk package to the latest version"""
+"""Update command"""
+from __future__ import annotations
+
 import json
-import subprocess
-import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, cast
 
 import click
 from packaging import version
 from rich.console import Console
 
 from moai_adk import __version__
+from moai_adk.core.template.processor import TemplateProcessor
 
 console = Console()
 
@@ -21,7 +25,6 @@ def get_latest_version() -> str | None:
     try:
         import urllib.error
         import urllib.request
-        from typing import cast
 
         url = "https://pypi.org/pypi/moai-adk/json"
         with urllib.request.urlopen(url, timeout=5) as response:  # nosec B310 - URL is hardcoded HTTPS to PyPI API, no user input
@@ -33,166 +36,319 @@ def get_latest_version() -> str | None:
         return None
 
 
-def detect_install_method() -> str:
-    """Detect how moai-adk was installed.
+def set_optimized_false(project_path: Path) -> None:
+    """Set config.json's optimized field to false.
 
-    Returns:
-        'uv-tool', 'uv-pip', or 'pip'
+    Args:
+        project_path: Project path (absolute).
     """
-    # Check if installed via uv tool
-    try:
-        result = subprocess.run(
-            ["uv", "tool", "list"],
-            capture_output=True,
-            text=True,
-            timeout=5,
-            check=False
-        )
-        if result.returncode == 0 and "moai-adk" in result.stdout:
-            return "uv-tool"
-    except (FileNotFoundError, subprocess.TimeoutExpired):
-        pass
+    config_path = project_path / ".moai" / "config.json"
+    if not config_path.exists():
+        return
 
-    # Check if uv is available (for uv pip)
     try:
-        subprocess.run(
-            ["uv", "--version"],
-            capture_output=True,
-            timeout=5,
-            check=False
+        config_data = json.loads(config_path.read_text(encoding="utf-8"))
+        config_data.setdefault("project", {})["optimized"] = False
+        config_path.write_text(
+            json.dumps(config_data, indent=2, ensure_ascii=False) + "\n",
+            encoding="utf-8"
         )
-        return "uv-pip"
-    except (FileNotFoundError, subprocess.TimeoutExpired):
+    except (json.JSONDecodeError, KeyError):
+        # Ignore errors if config.json is invalid
         pass
 
-    # Default to pip
-    return "pip"
 
+def _load_existing_config(project_path: Path) -> dict[str, Any]:
+    """Load existing config.json if available."""
+    config_path = project_path / ".moai" / "config.json"
+    if config_path.exists():
+        try:
+            return json.loads(config_path.read_text(encoding="utf-8"))
+        except json.JSONDecodeError:
+            console.print("[yellow]⚠ Existing config.json could not be parsed. Proceeding with defaults.[/yellow]")
+    return {}
+
+
+def _is_placeholder(value: Any) -> bool:
+    """Check if a string value is an unsubstituted template placeholder."""
+    return isinstance(value, str) and value.strip().startswith("{{") and value.strip().endswith("}}")
+
+
+def _coalesce(*values: Any, default: str = "") -> str:
+    """Return the first non-empty, non-placeholder string value."""
+    for value in values:
+        if isinstance(value, str):
+            if not value.strip():
+                continue
+            if _is_placeholder(value):
+                continue
+            return value
+    for value in values:
+        if value is not None and not isinstance(value, str):
+            return str(value)
+    return default
+
+
+def _extract_project_section(config: dict[str, Any]) -> dict[str, Any]:
+    """Return the nested project section if present."""
+    project_section = config.get("project")
+    if isinstance(project_section, dict):
+        return project_section
+    return {}
+
+
+def _build_template_context(
+    project_path: Path,
+    existing_config: dict[str, Any],
+    version_for_config: str,
+) -> dict[str, str]:
+    """Build substitution context for template files."""
+    project_section = _extract_project_section(existing_config)
+
+    project_name = _coalesce(
+        project_section.get("name"),
+        existing_config.get("projectName"),
+        project_path.name,
+    )
+    project_mode = _coalesce(
+        project_section.get("mode"),
+        existing_config.get("mode"),
+        default="personal",
+    )
+    project_description = _coalesce(
+        project_section.get("description"),
+        existing_config.get("projectDescription"),
+        existing_config.get("description"),
+    )
+    project_version = _coalesce(
+        project_section.get("version"),
+        existing_config.get("projectVersion"),
+        existing_config.get("version"),
+        default="0.1.0",
+    )
+    created_at = _coalesce(
+        project_section.get("created_at"),
+        existing_config.get("created_at"),
+        default=datetime.now().strftime("%Y-%m-%d %H:%M:%S"),
+    )
+
+    return {
+        "MOAI_VERSION": version_for_config,
+        "PROJECT_NAME": project_name,
+        "PROJECT_MODE": project_mode,
+        "PROJECT_DESCRIPTION": project_description,
+        "PROJECT_VERSION": project_version,
+        "CREATION_TIMESTAMP": created_at,
+    }
 
-def upgrade_package(install_method: str, target_version: str) -> bool:
-    """Upgrade moai-adk package.
-
-    Args:
-        install_method: 'uv-tool', 'uv-pip', or 'pip'
-        target_version: Target version to upgrade to
 
-    Returns:
-        True if successful, False otherwise
-    """
-    commands = {
-        "uv-tool": ["uv", "tool", "upgrade", "moai-adk"],
-        "uv-pip": ["uv", "pip", "install", "--upgrade", "moai-adk"],
-        "pip": [sys.executable, "-m", "pip", "install", "--upgrade", "moai-adk"],
-    }
+def _preserve_project_metadata(
+    project_path: Path,
+    context: dict[str, str],
+    existing_config: dict[str, Any],
+    version_for_config: str,
+) -> None:
+    """Restore project-specific metadata in the new config.json."""
+    config_path = project_path / ".moai" / "config.json"
+    if not config_path.exists():
+        return
 
-    cmd = commands.get(install_method)
-    if not cmd:
-        return False
+    try:
+        config_data = json.loads(config_path.read_text(encoding="utf-8"))
+    except json.JSONDecodeError:
+        console.print("[red]✗ Failed to parse config.json after template copy[/red]")
+        return
+
+    project_data = config_data.setdefault("project", {})
+    project_data["name"] = context["PROJECT_NAME"]
+    project_data["mode"] = context["PROJECT_MODE"]
+    project_data["description"] = context["PROJECT_DESCRIPTION"]
+    project_data["created_at"] = context["CREATION_TIMESTAMP"]
+    project_data["moai_adk_version"] = version_for_config
+
+    if "optimized" not in project_data and isinstance(existing_config, dict):
+        existing_project = _extract_project_section(existing_config)
+        if isinstance(existing_project, dict) and "optimized" in existing_project:
+            project_data["optimized"] = bool(existing_project["optimized"])
+
+    # Preserve locale and language preferences when possible
+    existing_project = _extract_project_section(existing_config)
+    locale = _coalesce(existing_project.get("locale"), existing_config.get("locale"))
+    if locale:
+        project_data["locale"] = locale
+
+    language = _coalesce(existing_project.get("language"), existing_config.get("language"))
+    if language:
+        project_data["language"] = language
+
+    config_data.setdefault("moai", {})
+    config_data["moai"]["version"] = version_for_config
+
+    config_path.write_text(
+        json.dumps(config_data, indent=2, ensure_ascii=False) + "\n",
+        encoding="utf-8"
+    )
+
+
+def _apply_context_to_file(processor: TemplateProcessor, target_path: Path) -> None:
+    """Apply the processor context to an existing file (post-merge pass)."""
+    if not processor.context or not target_path.exists():
+        return
 
     try:
-        console.print(f"\n[cyan]📦 Upgrading via {install_method}...[/cyan]")
-        console.print(f"[dim]   Command: {' '.join(cmd)}[/dim]")
-
-        result = subprocess.run(
-            cmd,
-            capture_output=True,
-            text=True,
-            timeout=120,
-            check=False
-        )
+        content = target_path.read_text(encoding="utf-8")
+    except UnicodeDecodeError:
+        return
 
-        if result.returncode == 0:
-            console.print(f"[green]✓ Upgraded to version {target_version}[/green]")
-            return True
-        else:
-            console.print(f"[red]✗ Upgrade failed[/red]")
-            if result.stderr:
-                console.print(f"[dim]{result.stderr.strip()}[/dim]")
-            return False
-
-    except subprocess.TimeoutExpired:
-        console.print("[red]✗ Upgrade timeout[/red]")
-        return False
-    except Exception as e:
-        console.print(f"[red]✗ Upgrade error: {e}[/red]")
-        return False
+    substituted, warnings = processor._substitute_variables(content)  # pylint: disable=protected-access
+    if warnings:
+        console.print("[yellow]⚠ Template warnings:[/yellow]")
+        for warning in warnings:
+            console.print(f"   {warning}")
+
+    target_path.write_text(substituted, encoding="utf-8")
 
 
 @click.command()
+@click.option(
+    "--path",
+    type=click.Path(exists=True),
+    default=".",
+    help="Project path (default: current directory)"
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Skip backup and force the update"
+)
 @click.option(
     "--check",
     is_flag=True,
-    help="Only check version (do not upgrade)"
+    help="Only check version (do not update)"
 )
-def update(check: bool) -> None:
-    """Upgrade moai-adk package to the latest version.
+def update(path: str, force: bool, check: bool) -> None:
+    """Update template files to the latest version.
 
-    This command automatically detects the installation method
-    (uv tool, uv pip, or pip) and upgrades the package accordingly.
-
-    For template updates, use 'moai-adk init .' instead.
+    Updates include:
+    - .claude/ (fully replaced)
+    - .moai/ (preserve specs and reports)
+    - CLAUDE.md (merged)
+    - config.json (smart merge)
 
     Examples:
-        moai-adk update              # Upgrade to latest version
-        moai-adk update --check      # Check version only
+        python -m moai_adk update              # update with backup
+        python -m moai_adk update --force      # update without backup
+        python -m moai_adk update --check      # check version only
     """
     try:
-        # Phase 1: Check versions
+        project_path = Path(path).resolve()
+
+        # Verify the project is initialized
+        if not (project_path / ".moai").exists():
+            console.print("[yellow]⚠ Project not initialized[/yellow]")
+            raise click.Abort()
+
+        existing_config = _load_existing_config(project_path)
+
+        # Phase 1: check versions
         console.print("[cyan]🔍 Checking versions...[/cyan]")
         current_version = __version__
         latest_version = get_latest_version()
+        version_for_config = current_version
 
         # Handle PyPI fetch failure
         if latest_version is None:
             console.print(f"   Current version: {current_version}")
             console.print("   Latest version:  [yellow]Unable to fetch from PyPI[/yellow]")
-            console.print("[yellow]⚠ Cannot check for updates[/yellow]")
-            return
-
-        console.print(f"   Current version: {current_version}")
-        console.print(f"   Latest version:  {latest_version}")
-
-        # Parse versions
-        current_ver = version.parse(current_version)
-        latest_ver = version.parse(latest_version)
+            if not force:
+                console.print("[yellow]⚠ Cannot check for updates. Use --force to update anyway.[/yellow]")
+                return
+        else:
+            console.print(f"   Current version: {current_version}")
+            console.print(f"   Latest version:  {latest_version}")
 
-        # Check mode
         if check:
-            if current_ver < latest_ver:
+            # Exit early when --check is provided
+            if latest_version is None:
+                console.print("[yellow]⚠ Unable to check for updates[/yellow]")
+            elif version.parse(current_version) < version.parse(latest_version):
                 console.print("[yellow]⚠ Update available[/yellow]")
-            elif current_ver > latest_ver:
+            elif version.parse(current_version) > version.parse(latest_version):
                 console.print("[green]✓ Development version (newer than PyPI)[/green]")
             else:
                 console.print("[green]✓ Already up to date[/green]")
             return
 
-        # Check if upgrade needed
-        if current_ver >= latest_ver:
-            console.print("[green]✓ Already up to date[/green]")
-            return
+        # Check if update is needed (version only) - skip with --force
+        if not force and latest_version is not None:
+            current_ver = version.parse(current_version)
+            latest_ver = version.parse(latest_version)
 
-        # Phase 2: Detect install method
-        install_method = detect_install_method()
-        console.print(f"\n[cyan]🔎 Detected installation method: {install_method}[/cyan]")
+            # Don't update if current version is newer
+            if current_ver > latest_ver:
+                console.print("[green]✓ Development version (newer than PyPI)[/green]")
+                return
+            # If versions are equal, check if we need to proceed
+            elif current_ver == latest_ver:
+                # Check if optimized=false (need to update templates)
+                config_path = project_path / ".moai" / "config.json"
+                if config_path.exists():
+                    try:
+                        config_data = json.loads(config_path.read_text())
+                        is_optimized = config_data.get("project", {}).get("optimized", False)
+
+                        if is_optimized:
+                            # Already up to date and optimized - exit silently
+                            return
+                        else:
+                            # Proceed with template update (optimized=false)
+                            console.print("[yellow]⚠ Template optimization needed[/yellow]")
+                    except (json.JSONDecodeError, KeyError):
+                        # If config.json is invalid, proceed with update
+                        pass
+                else:
+                    console.print("[green]✓ Already up to date[/green]")
+                    return
+
+        # Phase 2: create a backup unless --force
+        if not force:
+            console.print("\n[cyan]💾 Creating backup...[/cyan]")
+            processor = TemplateProcessor(project_path)
+            backup_path = processor.create_backup()
+            console.print(f"[green]✓ Backup completed: {backup_path.relative_to(project_path)}/[/green]")
+        else:
+            console.print("\n[yellow]⚠ Skipping backup (--force)[/yellow]")
 
-        # Phase 3: Upgrade package
-        success = upgrade_package(install_method, latest_version)
+        # Phase 3: update templates
+        console.print("\n[cyan]📄 Updating templates...[/cyan]")
+        processor = TemplateProcessor(project_path)
 
-        if success:
-            console.print("\n[green]✓ Update complete![/green]")
-            console.print("\n[dim]💡 For template updates, run: moai-adk init .[/dim]")
-        else:
-            console.print("\n[yellow]⚠ Upgrade failed. Please try manually:[/yellow]")
-            if install_method == "uv-tool":
-                console.print("   uv tool upgrade moai-adk")
-            elif install_method == "uv-pip":
-                console.print("   uv pip install --upgrade moai-adk")
-            else:
-                console.print("   pip install --upgrade moai-adk")
-            raise click.Abort()
+        context = _build_template_context(project_path, existing_config, version_for_config)
+        if context:
+            processor.set_context(context)
+
+        processor.copy_templates(backup=False, silent=True)  # Backup already handled
+
+        console.print("   [green]✅ .claude/ update complete[/green]")
+        console.print("   [green]✅ .moai/ update complete (specs/reports preserved)[/green]")
+        console.print("   [green]🔄 CLAUDE.md merge complete[/green]")
+        console.print("   [green]🔄 config.json merge complete[/green]")
+
+        _preserve_project_metadata(project_path, context, existing_config, version_for_config)
+        _apply_context_to_file(processor, project_path / "CLAUDE.md")
+
+        # Phase 4: set optimized=false
+        set_optimized_false(project_path)
+        console.print("   [yellow]⚙️  Set optimized=false (optimization needed)[/yellow]")
+
+        console.print("\n[green]✓ Update complete![/green]")
+        if latest_version and version.parse(current_version) < version.parse(latest_version):
+            console.print(
+                "[yellow]⚠ Python package still on older version. "
+                "Run 'pip install --upgrade moai-adk' to upgrade the CLI package.[/yellow]"
+            )
+        console.print("\n[cyan]ℹ️  Next step: Run /alfred:0-project update to optimize template changes[/cyan]")
 
-    except click.Abort:
-        raise
     except Exception as e:
         console.print(f"[red]✗ Update failed: {e}[/red]")
         raise click.ClickException(str(e)) from e

moai_adk/cli/prompts/init_prompts.py

@@ -18,7 +18,7 @@ class ProjectSetupAnswers(TypedDict):
 
     project_name: str
     mode: str  # personal | team
-    locale: str  # ko | en | ja | zh
+    locale: str  # ko | en
     language: str | None
     author: str
 
@@ -27,6 +27,7 @@ def prompt_project_setup(
     project_name: str | None = None,
     is_current_dir: bool = False,
     project_path: Path | None = None,
+    initial_locale: str | None = None,
 ) -> ProjectSetupAnswers:
     """Project setup prompt
 
@@ -34,6 +35,7 @@ def prompt_project_setup(
         project_name: Project name (asks when None)
         is_current_dir: Whether the current directory is being used
         project_path: Project path (used to derive the name)
+        initial_locale: Preferred locale provided via CLI (optional)
 
     Returns:
         Project setup answers
@@ -88,23 +90,17 @@ def prompt_project_setup(
         if result is None:
             raise KeyboardInterrupt
         answers["mode"] = result
+        answers["locale"] = initial_locale or "en"
+        if initial_locale:
+            console.print(
+                f"[cyan]🌐 Preferred Language:[/cyan] {answers['locale']} (specified via CLI option)"
+            )
+        else:
+            console.print(
+                "[cyan]🌐 Preferred Language:[/cyan] en (default, changeable in /alfred:0-project)"
+            )
 
-        # 3. Locale
-        result = questionary.select(
-            "🌐 Preferred Language:",
-            choices=[
-                questionary.Choice("Korean", value="ko"),
-                questionary.Choice("English", value="en"),
-                questionary.Choice("Japanese", value="ja"),
-                questionary.Choice("Chinese", value="zh"),
-            ],
-            default="ko",
-        ).ask()
-        if result is None:
-            raise KeyboardInterrupt
-        answers["locale"] = result
-
-        # 4. Programming language (auto-detect or manual)
+        # 3. Programming language (auto-detect or manual)
         result = questionary.confirm(
             "🔍 Auto-detect programming language?",
             default=True,
@@ -144,7 +140,7 @@ def prompt_project_setup(
                 raise KeyboardInterrupt
             answers["language"] = result
 
-        # 5. Author information (optional)
+        # 4. Author information (optional)
         result = questionary.confirm(
             "👤 Add author information? (optional)",
             default=False,

moai_adk/core/diagnostics/slash_commands.py

@@ -11,7 +11,7 @@ Functions:
 
 from pathlib import Path
 
-import yaml
+import yaml  # type: ignore[import-untyped]
 
 
 def validate_command_file(file_path: Path) -> dict:

moai_adk/core/project/backup_utils.py

@@ -3,10 +3,9 @@
 
 Selective backup strategy:
 - Back up only the required files (OR condition)
-- Backup path: .moai-backups/{timestamp}/ (v0.3.0)
+- Backup path: .moai-backups/backup/ (v0.4.2)
 """
 
-from datetime import datetime
 from pathlib import Path
 
 # Backup targets (OR condition - back up when any exist)
@@ -15,6 +14,7 @@ BACKUP_TARGETS = [
     ".moai/project/",
     ".moai/memory/",
     ".claude/",
+    ".github/",
     "CLAUDE.md",
 ]
 
@@ -58,15 +58,6 @@ def get_backup_targets(project_path: Path) -> list[str]:
     return targets
 
 
-def generate_backup_dir_name() -> str:
-    """Generate a timestamp-based backup directory name (v0.3.0).
-
-    Returns:
-        Timestamp formatted as YYYYMMDD-HHMMSS.
-        Note: callers use .moai-backups/{timestamp}/ format.
-    """
-    timestamp = datetime.now().strftime("%Y%m%d-%H%M%S")
-    return timestamp
 
 
 def is_protected_path(rel_path: Path) -> bool:

moai_adk/core/project/checker.py

@@ -298,5 +298,5 @@ def get_permission_fix_message(path: str) -> str:
         Platform-specific fix instructions.
     """
     if platform.system() == "Windows":
-        return f"관리자 권한으로 실행하거나 '{path}' 디렉토리 속성에서 권한을 확인하세요"
-    return f"chmod 755 {path} 실행 후 재시도하세요"
+        return f"Run with administrator privileges or verify permissions in the properties of the '{path}' directory"
+    return f"Run 'chmod 755 {path}' and try again"