moai-adk 0.15.0__py3-none-any.whl → 0.25.4__py3-none-any.whl

moai_adk/cli/commands/language.py

@@ -0,0 +1,269 @@
+"""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:
+                        console.print(
+                            f"[yellow]⚠ conversation_language_name '{conv_lang_name}' doesn't match expected '{expected_name}'[/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/migrate.py

@@ -0,0 +1,158 @@
+"""
+Migration CLI command for MoAI-ADK
+
+Provides command-line interface for project version migrations.
+"""
+
+import logging
+import sys
+from pathlib import Path
+
+import click
+
+from moai_adk.core.migration import VersionMigrator
+
+logger = logging.getLogger(__name__)
+
+
+@click.command()
+@click.option(
+    "--check",
+    is_flag=True,
+    help="Check if migration is needed without executing",
+)
+@click.option(
+    "--dry-run",
+    is_flag=True,
+    help="Show migration plan without making changes",
+)
+@click.option(
+    "--no-cleanup",
+    is_flag=True,
+    help="Keep old files after migration",
+)
+@click.option(
+    "--rollback",
+    is_flag=True,
+    help="Rollback to the latest backup",
+)
+@click.option(
+    "--list-backups",
+    is_flag=True,
+    help="List available backups",
+)
+def migrate(check, dry_run, no_cleanup, rollback, list_backups):
+    """
+    Migrate MoAI-ADK project to the latest version
+
+    This command automatically migrates your project structure to match
+    the latest MoAI-ADK version. It creates backups before migration
+    and can rollback if issues occur.
+
+    Examples:
+
+        # Check if migration is needed
+        moai-adk migrate --check
+
+        # Preview migration plan
+        moai-adk migrate --dry-run
+
+        # Execute migration
+        moai-adk migrate
+
+        # Migrate without cleaning up old files
+        moai-adk migrate --no-cleanup
+
+        # Rollback to latest backup
+        moai-adk migrate --rollback
+
+        # List available backups
+        moai-adk migrate --list-backups
+    """
+    try:
+        project_root = Path.cwd()
+        migrator = VersionMigrator(project_root)
+
+        # List backups
+        if list_backups:
+            backups = migrator.backup_manager.list_backups()
+            if not backups:
+                click.echo("📦 No backups found")
+                return
+
+            click.echo("📦 Available backups:\n")
+            for i, backup in enumerate(backups, 1):
+                click.echo(f"{i}. {backup['description']} ({backup['timestamp']})")
+                click.echo(f"   Path: {backup['path']}")
+                click.echo(f"   Files: {backup['files']}")
+                click.echo()
+            return
+
+        # Rollback
+        if rollback:
+            click.echo("🔙 Rolling back to latest backup...")
+            if migrator.rollback_to_latest_backup():
+                click.echo("✅ Rollback completed successfully")
+                sys.exit(0)
+            else:
+                click.echo("❌ Rollback failed", err=True)
+                sys.exit(1)
+
+        # Check status
+        if check:
+            status = migrator.check_status()
+            version_info = status["version"]
+            migration_info = status["migration"]
+
+            click.echo("📊 Migration Status:\n")
+            click.echo(f"Current Version: {version_info['detected_version']}")
+            click.echo(
+                f"Needs Migration: {'Yes' if version_info['needs_migration'] else 'No'}"
+            )
+
+            if version_info["needs_migration"]:
+                click.echo(f"Target Version: {migration_info['target_version']}")
+                click.echo(f"Files to migrate: {migration_info['file_count']}")
+                click.echo("\n💡 Run 'moai-adk migrate' to execute migration")
+            else:
+                click.echo("\n✅ Project is up to date")
+
+            return
+
+        # Dry run
+        if dry_run:
+            if migrator.needs_migration():
+                migrator.migrate_to_v024(dry_run=True)
+            else:
+                click.echo("✅ Project is already up to date")
+            return
+
+        # Execute migration
+        if not migrator.needs_migration():
+            click.echo("✅ Project is already up to date")
+            return
+
+        click.echo("🚀 MoAI-ADK Project Migration\n")
+        click.echo("This will migrate your project to v0.24.0")
+        click.echo("A backup will be created automatically\n")
+
+        # Confirm with user
+        if not click.confirm("Do you want to proceed?"):
+            click.echo("❌ Migration cancelled")
+            return
+
+        # Execute migration
+        success = migrator.migrate_to_v024(dry_run=False, cleanup=not no_cleanup)
+
+        if success:
+            click.echo("\n🎉 Migration completed successfully!")
+            sys.exit(0)
+        else:
+            click.echo("\n❌ Migration failed", err=True)
+            click.echo("💡 Use 'moai-adk migrate --rollback' to restore from backup")
+            sys.exit(1)
+
+    except Exception as e:
+        logger.error(f"Migration command failed: {e}", exc_info=True)
+        click.echo(f"❌ Error: {e}", err=True)
+        sys.exit(1)

moai_adk/cli/commands/status.py

@@ -1,4 +1,3 @@
-# @CODE:CLI-001 | SPEC: SPEC-CLI-001/spec.md | TEST: tests/unit/test_cli_commands.py
 """MoAI-ADK status command
 
 Project status display:
@@ -9,11 +8,8 @@ Project status display:
 ## 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,7 +27,7 @@ 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
@@ -58,10 +53,12 @@ def status() -> None:
     """
     try:
         # Read config.json
-        config_path = Path.cwd() / ".moai" / "config.json"
+        config_path = Path.cwd() / ".moai" / "config" / "config.json"
         if not config_path.exists():
-            console.print("[yellow]⚠ No .moai/config.json found[/yellow]")
-            console.print("[dim]Run [cyan]python -m moai_adk init .[/cyan] to initialize the project[/dim]")
+            console.print("[yellow]⚠ No .moai/config/config.json 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:
@@ -69,7 +66,9 @@ def status() -> None:
 
         # Count SPEC documents
         specs_dir = Path.cwd() / ".moai" / "specs"
-        spec_count = len(list(specs_dir.glob("SPEC-*/spec.md"))) if specs_dir.exists() else 0
+        spec_count = (
+            len(list(specs_dir.glob("SPEC-*/spec.md"))) if specs_dir.exists() else 0
+        )
 
         # Build the status table
         table = Table(show_header=False, box=None, padding=(0, 2))
@@ -79,7 +78,9 @@ def status() -> None:
         # Read from project section (with legacy fallback)
         project = config.get("project", {})
         table.add_row("Mode", project.get("mode") or config.get("mode", "unknown"))
-        table.add_row("Locale", project.get("locale") or config.get("locale", "unknown"))
+        table.add_row(
+            "Locale", project.get("locale") or config.get("locale", "unknown")
+        )
         table.add_row("SPECs", str(spec_count))
 
         # Optionally include Git information