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

moai_adk/cli/commands/init.py

@@ -1,4 +1,3 @@
-# @CODE:CLI-001 | @CODE:INIT-003:CLI
 # SPEC: SPEC-CLI-001.md, SPEC-INIT-003.md
 # TEST: tests/unit/test_cli_commands.py, tests/unit/test_init_reinit.py
 """MoAI-ADK init command
@@ -20,7 +19,7 @@ Project initialization command (interactive/non-interactive):
    - Run `Skill("moai-foundation-langs")` to validate detected language stack
 
 2. **Before first SPEC creation**:
-   - Use `Skill("moai-alfred-language-detection")` to confirm language selection
+   - Use `Skill("moai-core-language-detection")` to confirm language selection
 
 3. **Project reinitialization** (`--force`):
    - Skills automatically adapt to new project structure
@@ -32,12 +31,17 @@ from pathlib import Path
 from typing import Sequence
 
 import click
+import yaml
 from rich.console import Console
 from rich.progress import BarColumn, Progress, SpinnerColumn, TaskID, TextColumn
 
 from moai_adk import __version__
 from moai_adk.cli.prompts import prompt_project_setup
 from moai_adk.core.project.initializer import ProjectInitializer
+from moai_adk.statusline.version_reader import (
+    VersionConfig,
+    VersionReader,
+)
 from moai_adk.utils.banner import print_banner, print_welcome_message
 
 console = Console()
@@ -85,9 +89,9 @@ def create_progress_callback(progress: Progress, task_ids: Sequence[TaskID]):
 )
 @click.option(
     "--locale",
-    type=click.Choice(["ko", "en"]),
+    type=click.Choice(["ko", "en", "ja", "zh"]),
     default=None,
-    help="Preferred language (default: en)",
+    help="Preferred language (ko/en/ja/zh, default: en)",
 )
 @click.option(
     "--language",
@@ -114,26 +118,48 @@ 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). When omitted, defaults to en.
+        locale: Preferred language (ko/en/ja/zh). Interactive mode supports additional languages.
         language: Programming language
+        with_mcp: Install specific MCP servers (can be used multiple times)
+        mcp_auto: Auto-install all recommended MCP servers
         force: Force reinitialize without confirmation
     """
     try:
-        # 1. Print banner
+        # 1. Print banner with enhanced version info
         print_banner(__version__)
 
-        # 2. Check current directory mode
+        # 2. Enhanced version reading with error handling
+        try:
+            version_config = VersionConfig(
+                cache_ttl_seconds=10,  # Very short cache for CLI
+                fallback_version=__version__,
+                debug_mode=False,
+            )
+            version_reader = VersionReader(version_config)
+            current_version = version_reader.get_version()
+
+            # Log version info for debugging
+            console.print(f"[dim]Current MoAI-ADK version: {current_version}[/dim]")
+        except Exception as e:
+            console.print(f"[yellow]⚠️ Version read error: {e}[/yellow]")
+
+        # 3. Check current directory mode
         is_current_dir = path == "."
         project_path = Path(path).resolve()
 
+        # Initialize variables
+        custom_language = None
+
         # 3. Interactive vs Non-Interactive
         if non_interactive:
             # Non-Interactive Mode
-            console.print(
-                f"\n[cyan]🚀 Initializing project at {project_path}...[/cyan]\n"
-            )
+            console.print(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"
+            # Language detection happens in /moai:0-project, so default to None here
+            # This will become "generic" internally, but Summary will show more helpful message
+            if not language:
+                language = None
         else:
             # Interactive Mode
             print_welcome_message()
@@ -151,6 +177,7 @@ def init(
             locale = answers["locale"]
             language = answers["language"]
             project_name = answers["project_name"]
+            custom_language = answers.get("custom_language")
 
             console.print("\n[cyan]🚀 Starting installation...[/cyan]\n")
 
@@ -167,7 +194,7 @@ def init(
             else:
                 # Interactive mode: Simple notification
                 console.print("\n[cyan]🔄 Reinitializing project...[/cyan]")
-                console.print("   Backup will be created at .moai-backups/{timestamp}/\n")
+                console.print("   Backup will be created at .moai-backups/backup/\n")
 
         # 5. Initialize project (Progress Bar with 5 phases)
         # Always allow reinit (force mode by default)
@@ -175,25 +202,64 @@ def init(
 
         # Reinit mode: set config.json optimized to false (v0.3.1+)
         if is_reinit:
-            config_path = project_path / ".moai" / "config.json"
+            # Migration: Remove old hook files (Issue #163)
+            old_hook_files = [
+                ".claude/hooks/alfred/session_start__startup.py",  # v0.8.0 deprecated
+            ]
+            for old_file in old_hook_files:
+                old_path = project_path / old_file
+                if old_path.exists():
+                    try:
+                        old_path.unlink()  # Remove old file
+                    except Exception:
+                        pass  # Ignore removal failures
+
+            # Support both YAML (v0.32.5+) and JSON (legacy) config files
+            config_yaml_path = project_path / ".moai" / "config" / "config.yaml"
+            config_json_path = project_path / ".moai" / "config" / "config.json"
+
+            config_path = config_yaml_path if config_yaml_path.exists() else config_json_path
+            is_yaml = config_path.suffix in (".yaml", ".yml")
+
             if config_path.exists():
                 try:
                     with open(config_path, "r", encoding="utf-8") as f:
-                        config_data = json.load(f)
+                        if is_yaml:
+                            config_data = yaml.safe_load(f) or {}
+                        else:
+                            config_data = json.load(f)
 
                     # Update version and optimization flags
                     if "moai" not in config_data:
                         config_data["moai"] = {}
-                    config_data["moai"]["version"] = __version__
+
+                    # Use enhanced version reader for consistent version handling
+                    try:
+                        version_config = VersionConfig(
+                            cache_ttl_seconds=5,  # Very short cache for config update
+                            fallback_version=__version__,
+                            debug_mode=False,
+                        )
+                        version_reader = VersionReader(version_config)
+                        current_version = version_reader.get_version()
+                        config_data["moai"]["version"] = current_version
+                    except Exception:
+                        # Fallback to package version
+                        config_data["moai"]["version"] = __version__
 
                     if "project" not in config_data:
                         config_data["project"] = {}
                     config_data["project"]["optimized"] = False
 
                     with open(config_path, "w", encoding="utf-8") as f:
-                        json.dump(config_data, f, indent=2, ensure_ascii=False)
+                        if is_yaml:
+                            yaml.safe_dump(
+                                config_data, f, default_flow_style=False, allow_unicode=True, sort_keys=False
+                            )
+                        else:
+                            json.dump(config_data, f, indent=2, ensure_ascii=False)
                 except Exception:
-                    # Ignore read/write failures; config.json is regenerated during initialization
+                    # Ignore read/write failures; config is regenerated during initialization
                     pass
 
         with Progress(
@@ -218,6 +284,7 @@ def init(
                 mode=mode,
                 locale=locale,
                 language=language,
+                custom_language=custom_language,
                 backup_enabled=True,
                 progress_callback=callback,
                 reinit=True,  # Always allow reinit (force mode by default)
@@ -226,20 +293,17 @@ def init(
         # 6. Output results
         if result.success:
             separator = "[dim]" + ("─" * 60) + "[/dim]"
-            console.print(
-                "\n[green bold]✅ Initialization Completed Successfully![/green bold]"
-            )
+            console.print("\n[green bold]✅ Initialization Completed Successfully![/green bold]")
             console.print(separator)
             console.print("\n[cyan]📊 Summary:[/cyan]")
             console.print(f"  [dim]📁 Location:[/dim]  {result.project_path}")
-            console.print(f"  [dim]🌐 Language:[/dim]  {result.language}")
-            console.print(f"  [dim]🔧 Mode:[/dim]      {result.mode}")
-            console.print(
-                f"  [dim]🌍 Locale:[/dim]    {result.locale}"
-            )
-            console.print(
-                f"  [dim]📄 Files:[/dim]     {len(result.created_files)} created"
-            )
+            # Show language more clearly - "generic" means auto-detect
+            language_display = "Auto-detect (use /moai:0-project)" if result.language == "generic" else result.language
+            console.print(f"  [dim]🌐 Language:[/dim]  {language_display}")
+            # Show Git Strategy (default: manual = local-only, no auto-branch)
+            console.print("  [dim]🔀 Git:[/dim]       manual (github-flow, branch: manual)")
+            console.print(f"  [dim]🌍 Locale:[/dim]    {result.locale}")
+            console.print(f"  [dim]📄 Files:[/dim]     {len(result.created_files)} created")
             console.print(f"  [dim]⏱️  Duration:[/dim]  {result.duration}ms")
 
             # Show backup info if reinitialized
@@ -253,31 +317,37 @@ def init(
 
             # Show config merge notice if reinitialized
             if is_reinit:
-                console.print("\n[yellow]⚠️  Configuration Notice:[/yellow]")
-                console.print("  All template files have been [bold]force overwritten[/bold]")
-                console.print("  Previous files are backed up in [cyan].moai-backups/{timestamp}/[/cyan]")
-                console.print("\n  [cyan]To merge your previous config:[/cyan]")
-                console.print("  Run [bold]/alfred:0-project[/bold] command in Claude Code")
-                console.print("  It will merge backup config when [dim]optimized=false[/dim]\n")
+                console.print("\n[yellow]⚠️  Configuration Status: optimized=false (merge required)[/yellow]")
+                console.print()
+                console.print("[cyan]What Happened:[/cyan]")
+                console.print("  ✅ Template files updated to latest version")
+                console.print("  💾 Your previous settings backed up in: [cyan].moai-backups/backup/[/cyan]")
+                console.print("  ⏳ Configuration merge required")
+                console.print()
+                console.print("[cyan]What is optimized=false?[/cyan]")
+                console.print("  • Template version changed (you get new features)")
+                console.print("  • Your previous settings are safe (backed up)")
+                console.print("  • Next: Run /moai:0-project to merge")
+                console.print()
+                console.print("[cyan]What Happens Next:[/cyan]")
+                console.print("  1. Run [bold]/moai:0-project[/bold] in Claude Code")
+                console.print("  2. System intelligently merges old settings + new template")
+                console.print("  3. After successful merge → optimized becomes true")
+                console.print("  4. You're ready to continue developing\n")
 
             console.print("\n[cyan]🚀 Next Steps:[/cyan]")
             if not is_current_dir:
-                console.print(
-                    f"  [blue]1.[/blue] Run [bold]cd {project_name}[/bold] to enter the project"
-                )
-                console.print(
-                    "  [blue]2.[/blue] Check [bold].moai/config.json[/bold] for configuration"
-                )
-                console.print(
-                    "  [blue]3.[/blue] Read [bold]CLAUDE.md[/bold] for development guide\n"
-                )
+                console.print(f"  [blue]1.[/blue] Run [bold]cd {project_name}[/bold] to enter the project")
+                console.print("  [blue]2.[/blue] Run [bold]/moai:0-project[/bold] in Claude Code for full setup")
+                console.print("     (Configure: mode, language, report generation, etc.)")
+            else:
+                console.print("  [blue]1.[/blue] Run [bold]/moai:0-project[/bold] in Claude Code for full setup")
+                console.print("     (Configure: mode, language, report generation, etc.)")
+
+            if not is_current_dir:
+                console.print("  [blue]3.[/blue] Start developing with MoAI-ADK!\n")
             else:
-                console.print(
-                    "  [blue]1.[/blue] Check [bold].moai/config.json[/bold] for configuration"
-                )
-                console.print(
-                    "  [blue]2.[/blue] Read [bold]CLAUDE.md[/bold] for development guide\n"
-                )
+                console.print("  [blue]2.[/blue] Start developing with MoAI-ADK!\n")
         else:
             console.print("\n[red bold]❌ Initialization Failed![/red bold]")
             if result.errors:

moai_adk/cli/commands/language.py

@@ -0,0 +1,248 @@
+"""Language management commands for MoAI-ADK.
+
+Provides commands for language configuration, template processing,
+and multilingual content generation.
+"""
+
+import json
+from pathlib import Path
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from ...core.claude_integration import ClaudeCLIIntegration
+from ...core.language_config import (
+    LANGUAGE_CONFIG,
+    get_all_supported_codes,
+    get_native_name,
+    get_optimal_model,
+)
+from ...core.template_engine import TemplateEngine
+
+console = Console()
+
+
+@click.group()
+def language():
+    """Language management and multilingual support."""
+    pass
+
+
+@language.command()
+@click.option("--json-output", is_flag=True, help="Output as JSON")
+def list(json_output):
+    """List all supported languages."""
+    if json_output:
+        console.print(json.dumps(LANGUAGE_CONFIG, indent=2, ensure_ascii=False))
+        return
+
+    table = Table(title="Supported Languages")
+    table.add_column("Code", style="cyan", no_wrap=True)
+    table.add_column("English Name", style="green")
+    table.add_column("Native Name", style="yellow")
+    table.add_column("Family", style="blue")
+
+    for code, info in LANGUAGE_CONFIG.items():
+        table.add_row(code, info["name"], info["native_name"], info["family"])
+
+    console.print(table)
+
+
+@language.command()
+@click.argument("language_code")
+@click.option("--detail", is_flag=True, help="Show detailed information")
+def info(language_code, detail):
+    """Show information about a specific language."""
+    lang_info = LANGUAGE_CONFIG.get(language_code.lower())
+
+    if not lang_info:
+        console.print(f"[red]Language code '{language_code}' not found.[/red]")
+        console.print(f"Available codes: {', '.join(get_all_supported_codes())}")
+        return
+
+    console.print("[bold]Language Information:[/bold]")
+    console.print(f"Code: {language_code}")
+    console.print(f"English Name: {lang_info['name']}")
+    console.print(f"Native Name: {lang_info['native_name']}")
+    console.print(f"Family: {lang_info['family']}")
+
+    if detail:
+        optimal_model = get_optimal_model(language_code)
+        console.print(f"Optimal Claude Model: {optimal_model}")
+
+
+@language.command()
+@click.argument("template_path", type=click.Path(exists=True))
+@click.argument("variables_file", type=click.Path(exists=True))
+@click.option("--output", "-o", type=click.Path(), help="Output file path")
+@click.option("--language", "-l", help="Target language code")
+def render_template(template_path, variables_file, output, language):
+    """Render template with variables and language support."""
+    try:
+        # Load variables
+        with open(variables_file, "r", encoding="utf-8") as f:
+            variables = json.load(f)
+
+        # Add language info if specified
+        if language:
+            variables["CONVERSATION_LANGUAGE"] = language
+            variables["CONVERSATION_LANGUAGE_NAME"] = get_native_name(language)
+
+        # Render template
+        template_engine = TemplateEngine()
+        template_path_obj = Path(template_path)
+        output_path_obj = Path(output) if output else None
+
+        rendered = template_engine.render_file(template_path_obj, variables, output_path_obj)
+
+        if not output:
+            console.print("[bold]Rendered Template:[/bold]")
+            console.print(rendered)
+        else:
+            console.print(f"[green]Template rendered to: {output}[/green]")
+
+    except Exception as e:
+        console.print(f"[red]Error rendering template: {e}[/red]")
+
+
+@language.command()
+@click.argument("base_description")
+@click.option("--target-languages", "-t", help="Comma-separated target language codes")
+@click.option("--output", "-o", type=click.Path(), help="Output JSON file")
+def translate_descriptions(base_description, target_languages, output):
+    """Generate multilingual descriptions using Claude CLI."""
+    try:
+        if target_languages:
+            languages = [lang.strip() for lang in target_languages.split(",")]
+        else:
+            languages = ["en", "ko", "ja", "es", "fr", "de"]
+
+        claude_integration = ClaudeCLIIntegration()
+        descriptions = claude_integration.generate_multilingual_descriptions({"base": base_description}, languages)
+
+        if output:
+            with open(output, "w", encoding="utf-8") as f:
+                json.dump(descriptions, f, indent=2, ensure_ascii=False)
+            console.print(f"[green]Descriptions saved to: {output}[/green]")
+        else:
+            console.print("[bold]Multilingual Descriptions:[/bold]")
+            console.print(json.dumps(descriptions, indent=2, ensure_ascii=False))
+
+    except Exception as e:
+        console.print(f"[red]Error generating descriptions: {e}[/red]")
+
+
+@language.command()
+@click.argument("prompt_template")
+@click.option("--variables", "-v", type=click.Path(exists=True), help="Variables JSON file")
+@click.option("--language", "-l", help="Target language code")
+@click.option("--output-format", default="json", help="Output format (text, json, stream-json)")
+@click.option("--dry-run", is_flag=True, help="Show command without executing")
+def execute(prompt_template, variables, language, output_format, dry_run):
+    """Execute Claude CLI with template variables and language support."""
+    try:
+        # Load or create variables
+        template_vars = {}
+        if variables:
+            with open(variables, "r", encoding="utf-8") as f:
+                template_vars = json.load(f)
+
+        if language:
+            template_vars["CONVERSATION_LANGUAGE"] = language
+            template_vars["CONVERSATION_LANGUAGE_NAME"] = get_native_name(language)
+
+        # Process template
+        template_engine = TemplateEngine()
+        processed_prompt = template_engine.render_string(prompt_template, template_vars)
+
+        if dry_run:
+            console.print("[bold]Dry Run - Command that would be executed:[/bold]")
+            console.print(f"claude --print --output-format {output_format} '{processed_prompt}'")
+            console.print("[bold]Variables used:[/bold]")
+            console.print(json.dumps(template_vars, indent=2, ensure_ascii=False))
+            return
+
+        # Execute with Claude integration
+        claude_integration = ClaudeCLIIntegration()
+        result = claude_integration.process_template_command(
+            prompt_template, template_vars, print_mode=True, output_format=output_format
+        )
+
+        if result["success"]:
+            console.print("[green]✓ Command executed successfully[/green]")
+            if output_format == "json" and result["stdout"]:
+                try:
+                    output_data = json.loads(result["stdout"])
+                    console.print(json.dumps(output_data, indent=2, ensure_ascii=False))
+                except json.JSONDecodeError:
+                    console.print(result["stdout"])
+            else:
+                console.print(result["stdout"])
+        else:
+            console.print("[red]✗ Command execution failed[/red]")
+            if "error" in result:
+                console.print(f"Error: {result['error']}")
+            if result["stderr"]:
+                console.print(f"Stderr: {result['stderr']}")
+
+    except Exception as e:
+        console.print(f"[red]Error executing command: {e}[/red]")
+
+
+@language.command()
+@click.argument("config_file", type=click.Path(exists=True))
+@click.option("--validate-languages", is_flag=True, help="Validate language codes in config")
+def validate_config(config_file, validate_languages):
+    """Validate language configuration in MoAI-ADK config file."""
+    try:
+        with open(config_file, "r", encoding="utf-8") as f:
+            config = json.load(f)
+
+        console.print(f"[bold]Validating config: {config_file}[/bold]")
+
+        # Basic structure validation
+        if "language" not in config:
+            console.print("[yellow]⚠ No 'language' section found in config[/yellow]")
+        else:
+            lang_config = config["language"]
+            if not isinstance(lang_config, dict):
+                console.print("[red]✗ 'language' section must be an object[/red]")
+            else:
+                console.print("[green]✓ Language section structure is valid[/green]")
+
+                # Check conversation_language
+                conv_lang = lang_config.get("conversation_language")
+                if conv_lang:
+                    if conv_lang in get_all_supported_codes():
+                        console.print(f"[green]✓ conversation_language '{conv_lang}' is supported[/green]")
+                    else:
+                        console.print(f"[red]✗ conversation_language '{conv_lang}' is not supported[/red]")
+                else:
+                    console.print("[yellow]⚠ No conversation_language specified[/yellow]")
+
+                # Check conversation_language_name
+                conv_lang_name = lang_config.get("conversation_language_name")
+                if conv_lang_name and conv_lang:
+                    expected_name = get_native_name(conv_lang)
+                    if conv_lang_name == expected_name:
+                        console.print("[green]✓ conversation_language_name matches[/green]")
+                    else:
+                        warning_msg = (
+                            f"⚠ conversation_language_name '{conv_lang_name}' doesn't match expected '{expected_name}'"
+                        )
+                        console.print(f"[yellow]{warning_msg}[/yellow]")
+
+        if validate_languages:
+            # Scan entire config for language codes
+            config_str = json.dumps(config)
+            found_codes = []
+            for code in get_all_supported_codes():
+                if code in config_str:
+                    found_codes.append(code)
+
+            if found_codes:
+                console.print(f"[blue]Found language codes in config: {', '.join(found_codes)}[/blue]")
+
+    except Exception as e:
+        console.print(f"[red]Error validating config: {e}[/red]")

moai_adk/cli/commands/status.py

@@ -1,19 +1,15 @@
-# @CODE:CLI-001 | SPEC: SPEC-CLI-001/spec.md | TEST: tests/unit/test_cli_commands.py
 """MoAI-ADK status command
 
 Project status display:
-- Read project information from config.json
+- Read project information from config.yaml
 - Show the number of SPEC documents
 - Summarize the Git status
 
 ## Skill Invocation Guide (English-Only)
 
 ### Related Skills
-- **moai-foundation-tags**: For detailed TAG inventory and orphan detection
-  - Trigger: When you need to verify TAG chain integrity beyond what status shows
-  - Invocation: `Skill("moai-foundation-tags")` to scan full project for orphan TAGs
 
-- **moai-foundation-trust**: For comprehensive TRUST 5-principles verification
+- **moai-foundation-trust**: For comprehensive TRUST 4-principles verification
   - Trigger: After status shows SPECs exist, to validate code quality
   - Invocation: `Skill("moai-foundation-trust")` to verify all quality gates
 
@@ -23,7 +19,6 @@ Project status display:
 
 ### When to Invoke Skills in Related Workflows
 1. **Before starting new SPEC creation**:
-   - Run `Skill("moai-foundation-tags")` to verify no orphan TAGs exist from previous work
    - Check the SPEC count from status command
 
 2. **After modifications to code/docs**:
@@ -32,13 +27,13 @@ Project status display:
 
 3. **Periodic health checks**:
    - Run status command regularly
-   - When SPEC count grows, verify with `Skill("moai-foundation-tags")` and `Skill("moai-foundation-trust")`
+   - When SPEC count grows, verify with `Skill("moai-foundation-trust")`
 """
 
-import json
 from pathlib import Path
 
 import click
+import yaml
 from rich.console import Console
 from rich.panel import Panel
 from rich.table import Table
@@ -57,15 +52,15 @@ def status() -> None:
     - Git branch and status
     """
     try:
-        # Read config.json
-        config_path = Path.cwd() / ".moai" / "config.json"
+        # Read config.yaml
+        config_path = Path.cwd() / ".moai" / "config" / "config.yaml"
         if not config_path.exists():
-            console.print("[yellow]⚠ No .moai/config.json found[/yellow]")
+            console.print("[yellow]⚠ No .moai/config/config.yaml found[/yellow]")
             console.print("[dim]Run [cyan]python -m moai_adk init .[/cyan] to initialize the project[/dim]")
             raise click.Abort()
 
         with open(config_path) as f:
-            config = json.load(f)
+            config = yaml.safe_load(f) or {}
 
         # Count SPEC documents
         specs_dir = Path.cwd() / ".moai" / "specs"