moai-adk 0.15.1__py3-none-any.whl → 0.32.8__py3-none-any.whl

moai_adk/__init__.py

@@ -1,14 +1,10 @@
-# @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
 """
 
-from importlib.metadata import PackageNotFoundError, version
+from moai_adk.version import MOAI_VERSION
 
-try:
-    __version__ = version("moai-adk")
-except PackageNotFoundError:
-    __version__ = "0.5.6-dev"
+__version__ = MOAI_VERSION
 
 __all__ = ["__version__"]

moai_adk/__main__.py

@@ -1,38 +1,53 @@
-# @CODE:CLI-001 | SPEC: SPEC-CLI-001/spec.md | TEST: tests/unit/test_cli_commands.py
+# type: ignore
 """MoAI-ADK CLI Entry Point
 
 Implements the CLI entry point:
-- Click-based CLI framework
+- Click-based CLI framework with lazy command loading
 - Rich console terminal output
-- ASCII logo rendering
+- ASCII logo rendering (lazy-loaded)
 - --version and --help options
-- Five core commands: init, doctor, status, backup, update
+- Five core commands: init, doctor, status, update (lazy-loaded)
+
+Performance optimization: Commands and heavy libraries are lazy-loaded
+to reduce CLI startup time by 75% (~400ms → ~100ms).
 """
 
 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.status import status
-from moai_adk.cli.commands.update import update
 
-console = Console()
+# Lazy-loaded console (created when needed)
+_console = None
+
+
+def get_console():
+    """Get or create Rich Console instance (lazy loading)"""
+    global _console
+    if _console is None:
+        from rich.console import Console
+
+        _console = Console()
+    return _console
 
 
 def show_logo() -> None:
-    """Render the MoAI-ADK ASCII logo with Pyfiglet"""
+    """Render the MoAI-ADK ASCII logo with Pyfiglet (lazy-loaded)"""
+    # Lazy load pyfiglet only when displaying logo
+    import pyfiglet
+
+    console = get_console()
+
     # 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(
+        "  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")
@@ -54,11 +69,109 @@ def cli(ctx: click.Context) -> None:
     if ctx.invoked_subcommand is None:
         show_logo()
 
-cli.add_command(init)
-cli.add_command(doctor)
-cli.add_command(status)
-cli.add_command(backup)
-cli.add_command(update)
+
+# Lazy-loaded commands (imported only when invoked)
+@cli.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=None,
+    help="Preferred language (ko/en/ja/zh, default: en)",
+)
+@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",
+)
+@click.pass_context
+def init(
+    ctx: click.Context,
+    path: str,
+    non_interactive: bool,
+    mode: str,
+    locale: str,
+    language: str | None,
+    force: bool,
+) -> None:
+    """Initialize a new MoAI-ADK project"""
+    from moai_adk.cli.commands.init import init as _init
+
+    ctx.invoke(
+        _init,
+        path=path,
+        non_interactive=non_interactive,
+        mode=mode,
+        locale=locale,
+        language=language,
+        force=force,
+    )
+
+
+@cli.command()
+@click.pass_context
+def doctor(ctx: click.Context, **kwargs) -> None:
+    """Run system diagnostics"""
+    from moai_adk.cli.commands.doctor import doctor as _doctor
+
+    ctx.invoke(_doctor, **kwargs)
+
+
+@cli.command()
+@click.pass_context
+def status(ctx: click.Context, **kwargs) -> None:
+    """Show project status"""
+    from moai_adk.cli.commands.status import status as _status
+
+    ctx.invoke(_status, **kwargs)
+
+
+@cli.command()
+@click.pass_context
+def update(ctx: click.Context, **kwargs) -> None:
+    """Update MoAI-ADK to latest version"""
+    from moai_adk.cli.commands.update import update as _update
+
+    ctx.invoke(_update, **kwargs)
+
+
+# statusline command (for Claude Code statusline rendering)
+@cli.command(name="statusline")
+def statusline() -> None:
+    """Render Claude Code statusline (internal use only)"""
+    import json
+
+    # Lazy load statusline module
+    from moai_adk.statusline.main import build_statusline_data
+
+    try:
+        # Read JSON context from stdin
+        input_data = sys.stdin.read() if not sys.stdin.isatty() else "{}"
+        context = json.loads(input_data) if input_data else {}
+    except (json.JSONDecodeError, EOFError, ValueError):
+        context = {}
+
+    # Render statusline
+    output = build_statusline_data(context, mode="extended")
+    print(output, end="")
 
 
 def main() -> int:
@@ -73,11 +186,13 @@ def main() -> int:
         e.show()
         return e.exit_code
     except Exception as e:
+        console = get_console()
         console.print(f"[red]Error:[/red] {e}")
         return 1
     finally:
-        # Flush the output buffer explicitly
-        console.file.flush()
+        # Flush the output buffer explicitly if console was created
+        if _console is not None:
+            _console.file.flush()
 
 
 if __name__ == "__main__":

moai_adk/cli/__init__.py

@@ -1,2 +1,6 @@
-# @CODE:PY314-001 | SPEC: SPEC-PY314-001.md | TEST: tests/unit/test_foundation.py
-"""CLI module: Click-based command-line interface"""
+"""MoAI-ADK CLI Tools
+
+Command-line interface utilities for MoAI-ADK project management.
+"""
+
+__all__ = ["spec_status"]

moai_adk/cli/commands/__init__.py

@@ -1,4 +1,3 @@
-# @CODE:CLI-001 | SPEC: SPEC-CLI-001/spec.md | TEST: tests/unit/test_cli_commands.py
 """CLI command module
 
 Core commands:
@@ -6,15 +5,13 @@ Core commands:
 - doctor: run system diagnostics
 - status: show project status
 - update: update templates to latest version
-- backup: create project backups
 
 Note: restore functionality is handled by checkpoint system in core.git.checkpoint
 """
 
-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.status import status
 from moai_adk.cli.commands.update import update
 
-__all__ = ["init", "doctor", "status", "update", "backup"]
+__all__ = ["init", "doctor", "status", "update"]

moai_adk/cli/commands/analyze.py

@@ -0,0 +1,116 @@
+#!/usr/bin/env python3
+"""
+Analyze command for MoAI-ADK
+
+Analyze Claude Code sessions and generate improvement suggestions.
+"""
+
+from pathlib import Path
+from typing import Optional
+
+import click
+from rich.console import Console
+from rich.table import Table
+
+from moai_adk.core.analysis.session_analyzer import SessionAnalyzer
+
+console = Console()
+
+
+@click.command()
+@click.option("--days", "-d", default=7, help="Number of days to analyze (default: 7)")
+@click.option("--output", "-o", type=click.Path(), help="Output file path")
+@click.option("--verbose", "-v", is_flag=True, help="Verbose output")
+@click.option("--report-only", "-r", is_flag=True, help="Generate report only (no console output)")
+@click.option(
+    "--project-path",
+    "-p",
+    type=click.Path(),
+    help="Project root path (default: current directory)",
+)
+def analyze(
+    days: int,
+    output: Optional[Path],
+    verbose: bool,
+    report_only: bool,
+    project_path: Optional[Path],
+):
+    """
+    Analyze Claude Code sessions from the last N days
+
+    Analyzes Claude Code session logs to identify usage patterns,
+    error frequencies, and generate improvement suggestions.
+
+    Examples:
+        moai-adk analyze session
+        moai-adk analyze session --days 14 --verbose
+        moai-adk analyze session --output /path/to/report.md
+    """
+    if project_path is None:
+        project_path = Path.cwd()
+
+    # Validate project path
+    if not (project_path / ".moai").exists():
+        console.print("[red]Error:[/red] Not a MoAI-ADK project (missing .moai directory)")
+        console.print(f"[blue]Current path:[/blue] {project_path}")
+        return
+
+    # Initialize analyzer
+    analyzer = SessionAnalyzer(days_back=days, verbose=verbose)
+
+    if not report_only:
+        console.print(f"[blue]📊 Analyzing sessions from last {days} days...[/blue]")
+
+    # Parse sessions
+    patterns = analyzer.parse_sessions()
+
+    if not report_only:
+        console.print(f"[green]✅ Analyzed {patterns['total_sessions']} sessions[/green]")
+        console.print(f"[blue]   Total events: {patterns['total_events']}[/blue]")
+
+        # Display summary table
+        table = Table(title="Session Summary")
+        table.add_column("Metric", style="cyan")
+        table.add_column("Value", style="green")
+
+        table.add_row("Total Sessions", str(patterns["total_sessions"]))
+        table.add_row("Total Events", str(patterns["total_events"]))
+        table.add_row("Failed Sessions", str(patterns["failed_sessions"]))
+        table.add_row("Success Rate", f"{patterns.get('success_rate', 0):.1f}%")
+
+        console.print(table)
+
+        # Show top tools
+        if patterns["tool_usage"]:
+            console.print("\n[bold]🔧 Top Tools Used:[/bold]")
+            top_tools = sorted(patterns["tool_usage"].items(), key=lambda x: x[1], reverse=True)[:10]
+
+            tools_table = Table()
+            tools_table.add_column("Tool", style="cyan")
+            tools_table.add_column("Usage", style="green")
+
+            for tool, count in top_tools:
+                tools_table.add_row(f"`{tool}`", str(count))
+
+            console.print(tools_table)
+
+    # Save report
+    output_path_obj = Path(output) if output else None
+    report_path = analyzer.save_report(output_path_obj, project_path)
+
+    if not report_only:
+        console.print(f"\n[green]📄 Report saved: {report_path}[/green]")
+
+        # Show key suggestions
+        report_content = analyzer.generate_report()
+        if "💡 Improvement Suggestions" in report_content:
+            console.print("\n[bold yellow]💡 Key Suggestions:[/bold yellow]")
+            # Extract suggestions section
+            suggestions_start = report_content.find("💡 Improvement Suggestions")
+            if suggestions_start != -1:
+                suggestions_section = report_content[suggestions_start:]
+                # Extract first few suggestions
+                lines = suggestions_section.split("\n")[2:]  # Skip header and empty line
+                for line in lines[:10]:  # Show first 10 lines
+                    if line.strip() and not line.startswith("---"):
+                        console.print(line)

moai_adk/cli/commands/doctor.py

@@ -1,5 +1,3 @@
-# @CODE:CLI-001 | SPEC: SPEC-CLI-001/spec.md | TEST: tests/unit/test_doctor.py
-# @CODE:CLAUDE-COMMANDS-001:CLI | SPEC: SPEC-CLAUDE-COMMANDS-001/spec.md | TEST: tests/unit/test_slash_commands.py
 """MoAI-ADK doctor command
 
 System diagnostics command:
@@ -49,12 +47,23 @@ console = Console()
 
 
 @click.command()
-@click.option("--verbose", "-v", is_flag=True, help="Show detailed tool versions and language detection")
+@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")
 @click.option("--check-commands", is_flag=True, help="Diagnose slash command loading issues")
-def doctor(verbose: bool, fix: bool, export: str | None, check: str | None, check_commands: bool) -> None:
+def doctor(
+    verbose: bool,
+    fix: bool,
+    export: str | None,
+    check: str | None,
+    check_commands: bool,
+) -> None:
     """Check system requirements and project health
 
     Verifies:
@@ -110,7 +119,10 @@ def doctor(verbose: bool, fix: bool, export: str | None, check: str | None, chec
 
         # 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"))
+            _suggest_fixes(
+                diagnostics_data["language_tools"],
+                diagnostics_data.get("detected_language"),
+            )
 
         # When exporting, write diagnostics to JSON
         if export:

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")
 
@@ -187,25 +214,52 @@ def init(
                     except Exception:
                         pass  # Ignore removal failures
 
-            config_path = project_path / ".moai" / "config.json"
+            # 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(
@@ -230,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)
@@ -238,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
@@ -265,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/backup/[/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: