moai-adk 0.3.0__py3-none-any.whl

moai_adk/__init__.py

@@ -0,0 +1,8 @@
+# @CODE:PY314-001 | SPEC: SPEC-PY314-001.md | TEST: tests/unit/test_foundation.py
+"""MoAI Agentic Development Kit
+
+SPEC-First TDD Framework with Alfred SuperAgent
+"""
+
+__version__ = "0.3.0"
+__all__ = ["__version__"]

moai_adk/__main__.py

@@ -0,0 +1,86 @@
+# @CODE:CLI-001 | SPEC: SPEC-CLI-001.md | TEST: tests/unit/test_cli_commands.py
+"""MoAI-ADK CLI Entry Point
+
+Implements the CLI entry point:
+- Click-based CLI framework
+- Rich console terminal output
+- ASCII logo rendering
+- --version and --help options
+- Six core commands: init, doctor, status, backup, restore, update
+"""
+
+import sys
+
+import click
+import pyfiglet
+from rich.console import Console
+
+from moai_adk import __version__
+from moai_adk.cli.commands.backup import backup
+from moai_adk.cli.commands.doctor import doctor
+from moai_adk.cli.commands.init import init
+from moai_adk.cli.commands.restore import restore
+from moai_adk.cli.commands.status import status
+from moai_adk.cli.commands.update import update
+
+console = Console()
+
+
+def show_logo() -> None:
+    """Render the MoAI-ADK ASCII logo with Pyfiglet"""
+    # Generate the "MoAI-ADK" banner using the ansi_shadow font
+    logo = pyfiglet.figlet_format("MoAI-ADK", font="ansi_shadow")
+
+    # Print with Rich styling
+    console.print(logo, style="cyan bold", highlight=False)
+    console.print("  Modu-AI's Agentic Development Kit w/ SuperAgent 🎩 Alfred", style="yellow bold")
+    console.print()
+    console.print("  Version: ", style="green", end="")
+    console.print(__version__, style="cyan bold")
+    console.print()
+    console.print("  Tip: Run ", style="yellow", end="")
+    console.print("python -m moai_adk --help", style="cyan", end="")
+    console.print(" to see available commands", style="yellow")
+
+
+@click.group(invoke_without_command=True)
+@click.version_option(version=__version__, prog_name="MoAI-ADK")
+@click.pass_context
+def cli(ctx: click.Context) -> None:
+    """MoAI Agentic Development Kit
+
+    SPEC-First TDD Framework with Alfred SuperAgent
+    """
+    # Display the logo when no subcommand is invoked
+    if ctx.invoked_subcommand is None:
+        show_logo()
+
+cli.add_command(init)
+cli.add_command(doctor)
+cli.add_command(status)
+cli.add_command(restore)
+cli.add_command(backup)
+cli.add_command(update)
+
+
+def main() -> int:
+    """CLI entry point"""
+    try:
+        cli(standalone_mode=False)
+        return 0
+    except click.Abort:
+        # User cancelled with Ctrl+C
+        return 130
+    except click.ClickException as e:
+        e.show()
+        return e.exit_code
+    except Exception as e:
+        console.print(f"[red]Error:[/red] {e}")
+        return 1
+    finally:
+        # Flush the output buffer explicitly
+        console.file.flush()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

moai_adk/cli/__init__.py

@@ -0,0 +1,2 @@
+# @CODE:PY314-001 | SPEC: SPEC-PY314-001.md | TEST: tests/unit/test_foundation.py
+"""CLI module: Click-based command-line interface"""

moai_adk/cli/commands/__init__.py

@@ -0,0 +1,16 @@
+# @CODE:CLI-001 | SPEC: SPEC-CLI-001.md | TEST: tests/unit/test_cli_commands.py
+"""CLI command module
+
+Four core commands:
+- init: initialize the project
+- doctor: run system diagnostics
+- status: show project status
+- restore: restore backups
+"""
+
+from moai_adk.cli.commands.doctor import doctor
+from moai_adk.cli.commands.init import init
+from moai_adk.cli.commands.restore import restore
+from moai_adk.cli.commands.status import status
+
+__all__ = ["init", "doctor", "status", "restore"]

moai_adk/cli/commands/backup.py

@@ -0,0 +1,56 @@
+"""Backup command"""
+from pathlib import Path
+
+import click
+from rich.console import Console
+
+from moai_adk.core.template.processor import TemplateProcessor
+
+console = Console()
+
+
+@click.command()
+@click.option(
+    "--path",
+    type=click.Path(exists=True),
+    default=".",
+    help="Project path (default: current directory)"
+)
+def backup(path: str) -> None:
+    """Create a backup of the current project.
+
+    Includes:
+    - .claude/ (entire directory)
+    - .moai/ (excluding specs and reports)
+    - CLAUDE.md
+
+    Backup location: .moai-backup/YYYYMMDD-HHMMSS/
+    """
+    try:
+        project_path = Path(path).resolve()
+
+        # Verify the project has been initialized
+        if not (project_path / ".moai").exists():
+            console.print("[yellow]⚠ Project not initialized[/yellow]")
+            raise click.Abort()
+
+        # Create the backup
+        console.print("[cyan]💾 Creating backup...[/cyan]")
+        processor = TemplateProcessor(project_path)
+        backup_path = processor.create_backup()
+
+        # Success message
+        console.print(f"[green]✓ Backup completed: {backup_path.relative_to(project_path)}[/green]")
+
+        # Show backup contents
+        backup_items = list(backup_path.iterdir())
+        for item in backup_items:
+            if item.is_dir():
+                file_count = len(list(item.rglob("*")))
+                console.print(f"   ├─ {item.name}/ ({file_count} files)")
+            else:
+                console.print(f"   └─ {item.name}")
+
+    except Exception as e:
+        console.print(f"[red]✗ Backup failed: {e}[/red]")
+        raise click.ClickException(str(e)) from e

moai_adk/cli/commands/doctor.py

@@ -0,0 +1,184 @@
+# @CODE:CLI-001 | SPEC: SPEC-CLI-001.md | TEST: tests/unit/test_doctor.py
+"""MoAI-ADK doctor command
+
+System diagnostics command:
+- Check the Python version
+- Verify Git installation
+- Validate project structure
+- Inspect language-specific tool chains
+"""
+
+import json
+from pathlib import Path
+
+import click
+import questionary
+from rich.console import Console
+from rich.table import Table
+
+from moai_adk.core.project.checker import SystemChecker, check_environment
+from moai_adk.core.project.detector import detect_project_language
+
+console = Console()
+
+
+@click.command()
+@click.option("--verbose", "-v", is_flag=True, help="Show detailed tool versions and language detection")
+@click.option("--fix", is_flag=True, help="Suggest fixes for missing tools")
+@click.option("--export", type=click.Path(), help="Export diagnostics to JSON file")
+@click.option("--check", type=str, help="Check specific tool only")
+def doctor(verbose: bool, fix: bool, export: str | None, check: str | None) -> None:
+    """Check system requirements and project health
+
+    Verifies:
+    - Python version (>= 3.13)
+    - Git installation
+    - Project structure (.moai directory)
+    - Language-specific tool chains (20+ languages)
+    """
+    try:
+        console.print("[cyan]Running system diagnostics...[/cyan]\n")
+
+        # Run basic environment checks
+        results = check_environment()
+        diagnostics_data: dict = {"basic_checks": results}
+
+        # In verbose mode, verify language-specific toolchains
+        if verbose or fix:
+            language = detect_project_language()
+            diagnostics_data["detected_language"] = language
+
+            if verbose:
+                console.print(f"[dim]Detected language: {language or 'Unknown'}[/dim]\n")
+
+            if language:
+                checker = SystemChecker()
+                language_tools = checker.check_language_tools(language)
+                diagnostics_data["language_tools"] = language_tools
+
+                if verbose:
+                    _display_language_tools(language, language_tools, checker)
+
+        # Specific tool check
+        if check:
+            _check_specific_tool(check)
+            return
+
+        # Build the base results table
+        table = Table(show_header=True, header_style="bold magenta")
+        table.add_column("Check", style="dim", width=40)
+        table.add_column("Status", justify="center")
+
+        for check_name, status in results.items():
+            icon = "✓" if status else "✗"
+            color = "green" if status else "red"
+            table.add_row(check_name, f"[{color}]{icon}[/{color}]")
+
+        console.print(table)
+
+        # In fix mode, suggest installation commands for missing tools
+        if fix and "language_tools" in diagnostics_data:
+            _suggest_fixes(diagnostics_data["language_tools"], diagnostics_data.get("detected_language"))
+
+        # When exporting, write diagnostics to JSON
+        if export:
+            _export_diagnostics(export, diagnostics_data)
+
+        # Summarize the overall result
+        all_passed = all(results.values())
+        if all_passed:
+            console.print("\n[green]✓ All checks passed[/green]")
+        else:
+            console.print("\n[yellow]⚠ Some checks failed[/yellow]")
+            console.print("[dim]Run [cyan]python -m moai_adk doctor --verbose[/cyan] for detailed diagnostics[/dim]")
+
+    except Exception as e:
+        console.print(f"[red]✗ Diagnostic failed: {e}[/red]")
+        raise
+
+
+def _display_language_tools(language: str, tools: dict[str, bool], checker: SystemChecker) -> None:
+    """Display a table of language-specific tools (helper)"""
+    table = Table(show_header=True, header_style="bold cyan", title=f"{language.title()} Tools")
+    table.add_column("Tool", style="dim")
+    table.add_column("Status", justify="center")
+    table.add_column("Version", style="blue")
+
+    for tool, available in tools.items():
+        icon = "✓" if available else "✗"
+        color = "green" if available else "red"
+        version = checker.get_tool_version(tool) if available else "not installed"
+
+        table.add_row(tool, f"[{color}]{icon}[/{color}]", version or "")
+
+    console.print(table)
+    console.print()
+
+
+def _check_specific_tool(tool: str) -> None:
+    """Check only a specific tool (helper)"""
+    checker = SystemChecker()
+    available = checker._is_tool_available(tool)
+    version = checker.get_tool_version(tool) if available else None
+
+    if available:
+        console.print(f"[green]✓ {tool} is installed[/green]")
+        if version:
+            console.print(f"  Version: {version}")
+    else:
+        console.print(f"[red]✗ {tool} is not installed[/red]")
+
+
+def _suggest_fixes(tools: dict[str, bool], language: str | None) -> None:
+    """Suggest installation commands for missing tools (helper)"""
+    missing_tools = [tool for tool, available in tools.items() if not available]
+
+    if not missing_tools:
+        console.print("\n[green]✓ All tools are installed[/green]")
+        return
+
+    console.print(f"\n[yellow]⚠ Missing {len(missing_tools)} tool(s)[/yellow]")
+
+    try:
+        proceed = questionary.confirm(
+            "Would you like to see install suggestions for missing tools?",
+            default=True,
+        ).ask()
+    except Exception:
+        proceed = True
+
+    if not proceed:
+        console.print("[yellow]User skipped install suggestions[/yellow]")
+        return
+
+    for tool in missing_tools:
+        install_cmd = _get_install_command(tool, language)
+        console.print(f"  [red]✗[/red] {tool}")
+        if install_cmd:
+            console.print(f"    Install: [cyan]{install_cmd}[/cyan]")
+
+
+def _get_install_command(tool: str, language: str | None) -> str:
+    """Return the install command for a given tool (helper)"""
+    # Common tools
+    install_commands = {
+        "pytest": "pip install pytest",
+        "mypy": "pip install mypy",
+        "ruff": "pip install ruff",
+        "vitest": "npm install -D vitest",
+        "biome": "npm install -D @biomejs/biome",
+        "eslint": "npm install -D eslint",
+        "jest": "npm install -D jest",
+    }
+
+    return install_commands.get(tool, f"# Install {tool} for {language}")
+
+
+def _export_diagnostics(export_path: str, data: dict) -> None:
+    """Export diagnostic results to a JSON file (helper)"""
+    try:
+        output = Path(export_path)
+        output.write_text(json.dumps(data, indent=2))
+        console.print(f"\n[green]✓ Diagnostics exported to {export_path}[/green]")
+    except Exception as e:
+        console.print(f"\n[red]✗ Failed to export diagnostics: {e}[/red]")

moai_adk/cli/commands/init.py

@@ -0,0 +1,284 @@
+# @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
+
+Project initialization command (interactive/non-interactive):
+- Interactive Mode: Ask user for project settings
+- Non-Interactive Mode: Use defaults or CLI options
+"""
+
+import json
+from pathlib import Path
+from typing import Sequence
+
+import click
+from rich.console import Console
+from rich.progress import BarColumn, Progress, SpinnerColumn, TaskID, TextColumn
+from rich.prompt import Confirm
+
+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.utils.banner import print_banner, print_welcome_message
+
+console = Console()
+
+
+def create_progress_callback(progress: Progress, task_ids: Sequence[TaskID]):
+    """Create progress callback
+
+    Args:
+        progress: Rich Progress object
+        task_ids: List of task IDs (one per phase)
+
+    Returns:
+        Progress callback function
+    """
+
+    def callback(message: str, current: int, total: int) -> None:
+        """Update progress
+
+        Args:
+            message: Progress message
+            current: Current phase (1-based)
+            total: Total phases
+        """
+        # Complete current phase (1-based index → 0-based)
+        if 1 <= current <= len(task_ids):
+            progress.update(task_ids[current - 1], completed=1, description=message)
+
+    return callback
+
+
+@click.command()
+@click.argument("path", type=click.Path(), default=".")
+@click.option(
+    "--non-interactive",
+    "-y",
+    is_flag=True,
+    help="Non-interactive mode (use defaults)",
+)
+@click.option(
+    "--mode",
+    type=click.Choice(["personal", "team"]),
+    default="personal",
+    help="Project mode",
+)
+@click.option(
+    "--locale",
+    type=click.Choice(["ko", "en", "ja", "zh"]),
+    default="ko",
+    help="Preferred language",
+)
+@click.option(
+    "--language",
+    type=str,
+    default=None,
+    help="Programming language (auto-detect if not specified)",
+)
+@click.option(
+    "--force",
+    is_flag=True,
+    help="Force reinitialize without confirmation",
+)
+def init(
+    path: str,
+    non_interactive: bool,
+    mode: str,
+    locale: str,
+    language: str | None,
+    force: bool,
+) -> None:
+    """Initialize a new MoAI-ADK project
+
+    Args:
+        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)
+        language: Programming language
+        force: Force reinitialize without confirmation
+    """
+    try:
+        # 1. Print banner
+        print_banner()
+
+        # 2. Check current directory mode
+        is_current_dir = path == "."
+        project_path = Path(path).resolve()
+
+        # 3. Interactive vs Non-Interactive
+        if non_interactive:
+            # Non-Interactive Mode
+            console.print(
+                f"\n[cyan]🚀 Initializing project at {project_path}...[/cyan]\n"
+            )
+            project_name = project_path.name if is_current_dir else path
+        else:
+            # Interactive Mode
+            print_welcome_message()
+
+            # Interactive prompt
+            answers = prompt_project_setup(
+                project_name=None if is_current_dir else path,
+                is_current_dir=is_current_dir,
+                project_path=project_path,
+            )
+
+            # Override with prompt answers
+            mode = answers["mode"]
+            locale = answers["locale"]
+            language = answers["language"]
+            project_name = answers["project_name"]
+
+            console.print("\n[cyan]🚀 Starting installation...[/cyan]\n")
+
+        # 4. Check for reinitialization (SPEC-INIT-003 v0.3.0)
+        initializer = ProjectInitializer(project_path)
+
+        if initializer.is_initialized():
+            if non_interactive and not force:
+                # Non-interactive mode (without force): Reject reinitialization
+                console.print("\n[yellow]⚠ Project already initialized[/yellow]")
+                console.print(f"[dim]  Location: {project_path}/.moai/[/dim]")
+                console.print("[dim]  Use --force to reinitialize or interactive mode[/dim]\n")
+                raise click.Abort()
+
+            if force:
+                # Force mode: Reinitialize without confirmation
+                console.print("\n[green]🔄 Force reinitializing project...[/green]\n")
+            else:
+                # Interactive mode: Reinitialization prompt
+                console.print("\n⚠️  [yellow]Project already initialized[/yellow]")
+                console.print(f"   Location: {project_path}/.moai/\n")
+
+                console.print("[cyan]This will:[/cyan]")
+                console.print("  ✓ Backup existing files to .moai-backups/{timestamp}/")
+                console.print("    • CLAUDE.md")
+                console.print("    • .claude/ (settings, commands, hooks)")
+                console.print("    • .moai/ (all configurations and specs)")
+                console.print("  ✓ Update template files from moai-adk v0.3.0")
+                console.print("    • .claude/ → Latest Alfred commands")
+                console.print("    • .moai/memory/ → Latest development guides")
+                console.print("    • CLAUDE.md → Latest project documentation")
+                console.print("  ✓ Preserve your content")
+                console.print("    • .moai/project/ (product/structure/tech.md)")
+                console.print("    • .moai/specs/ (all SPEC documents)\n")
+
+                if not Confirm.ask("Would you like to update the project templates?", default=True):
+                    console.print("\n[yellow]Reinit cancelled.[/yellow]\n")
+                    raise click.Abort()
+
+                console.print("\n[green]🔄 Starting reinit process...[/green]\n")
+
+        # 5. Initialize project (Progress Bar with 5 phases)
+        is_reinit = initializer.is_initialized()
+
+        # Reinit mode: set config.json optimized to false (v0.3.1+)
+        if is_reinit:
+            config_path = project_path / ".moai" / "config.json"
+            if config_path.exists():
+                try:
+                    with open(config_path, "r", encoding="utf-8") as f:
+                        config_data = json.load(f)
+
+                    # Update version and optimization flags
+                    if "project" not in config_data:
+                        config_data["project"] = {}
+
+                    config_data["project"]["moai_adk_version"] = __version__
+                    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)
+                except Exception:
+                    # Ignore read/write failures; config.json is regenerated during initialization
+                    pass
+
+        with Progress(
+            SpinnerColumn(),
+            TextColumn("[progress.description]{task.description}"),
+            BarColumn(),
+            TextColumn("[progress.percentage]{task.percentage:>3.0f}%"),
+            console=console,
+        ) as progress:
+            # Create 5 phase tasks
+            phase_names = [
+                "Phase 1: Preparation and backup...",
+                "Phase 2: Creating directory structure...",
+                "Phase 3: Installing resources...",
+                "Phase 4: Generating configurations...",
+                "Phase 5: Validation and finalization...",
+            ]
+            task_ids = [progress.add_task(name, total=1) for name in phase_names]
+            callback = create_progress_callback(progress, task_ids)
+
+            result = initializer.initialize(
+                mode=mode,
+                locale=locale,
+                language=language,
+                backup_enabled=True,
+                progress_callback=callback,
+                reinit=is_reinit,  # SPEC-INIT-003 v0.3.0
+            )
+
+        # 6. Output results
+        if result.success:
+            separator = "[dim]" + ("─" * 60) + "[/dim]"
+            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"
+            )
+            console.print(f"  [dim]⏱️  Duration:[/dim]  {result.duration}ms")
+            console.print(f"\n{separator}")
+            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"
+                )
+            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"
+                )
+        else:
+            console.print("\n[red bold]❌ Initialization Failed![/red bold]")
+            if result.errors:
+                console.print("\n[red]Errors:[/red]")
+                for error in result.errors:
+                    console.print(f"  [red]•[/red] {error}")
+            console.print()
+            raise click.ClickException("Installation failed")
+
+    except KeyboardInterrupt:
+        console.print("\n\n[yellow]⚠ Initialization cancelled by user[/yellow]\n")
+        raise click.Abort()
+    except FileExistsError as e:
+        console.print("\n[yellow]⚠ Project already initialized[/yellow]")
+        console.print("[dim]  Use 'python -m moai_adk status' to check configuration[/dim]\n")
+        raise click.Abort() from e
+    except Exception as e:
+        console.print(f"\n[red]✗ Initialization failed: {e}[/red]\n")
+        raise click.ClickException(str(e)) from e
+    finally:
+        # Explicitly flush output buffer
+        console.file.flush()