moai-adk 0.35.1__py3-none-any.whl

moai_adk/__init__.py

@@ -0,0 +1,10 @@
+"""MoAI Agentic Development Kit
+
+SPEC-First TDD Framework with Alfred SuperAgent
+"""
+
+from moai_adk.version import MOAI_VERSION
+
+__version__ = MOAI_VERSION
+
+__all__ = ["__version__"]

moai_adk/__main__.py

@@ -0,0 +1,199 @@
+# type: ignore
+"""MoAI-ADK CLI Entry Point
+
+Implements the CLI entry point:
+- Click-based CLI framework with lazy command loading
+- Rich console terminal output
+- ASCII logo rendering (lazy-loaded)
+- --version and --help options
+- 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
+
+from moai_adk import __version__
+
+# 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 (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()
+    console.print("  Version: ", style="green", end="")
+    console.print(__version__, style="cyan bold")
+    console.print()
+    console.print("  Tip: Run ", style="yellow", end="")
+    console.print("uv run 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()
+
+
+# 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:
+    """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 = get_console()
+        console.print(f"[red]Error:[/red] {e}")
+        return 1
+    finally:
+        # Flush the output buffer explicitly if console was created
+        if _console is not None:
+            _console.file.flush()
+
+
+if __name__ == "__main__":
+    sys.exit(main())

moai_adk/cli/__init__.py

@@ -0,0 +1,6 @@
+"""MoAI-ADK CLI Tools
+
+Command-line interface utilities for MoAI-ADK project management.
+"""
+
+__all__ = ["spec_status"]

moai_adk/cli/commands/__init__.py

@@ -0,0 +1,17 @@
+"""CLI command module
+
+Core commands:
+- init: initialize the project
+- doctor: run system diagnostics
+- status: show project status
+- update: update templates to latest version
+
+Note: restore functionality is handled by checkpoint system in core.git.checkpoint
+"""
+
+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"]

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

@@ -0,0 +1,272 @@
+"""MoAI-ADK doctor command
+
+System diagnostics command:
+- Check the Python version
+- Verify Git installation
+- Validate project structure
+- Inspect language-specific tool chains
+- Diagnose slash command loading issues (--check-commands)
+
+## Skill Invocation Guide (English-Only)
+
+### Related Skills
+- **moai-foundation-langs**: For language toolchain verification and detection
+  - Trigger: Use `--verbose` or `--fix` flag to inspect language-specific tools
+  - Invocation: `Skill("moai-foundation-langs")` for detailed language stack analysis
+
+- **moai-foundation-trust**: For TRUST 5-principles verification after fixing tools
+  - Trigger: After running doctor with `--fix` to validate improvements
+  - Invocation: `Skill("moai-foundation-trust")` to verify code quality toolchain
+
+### When to Invoke Skills in Related Workflows
+1. **After doctor diagnosis**:
+   - Run `Skill("moai-foundation-trust")` to validate that all TRUST tools are properly configured
+   - Run `Skill("moai-foundation-langs")` to confirm language-specific toolchains
+
+2. **When tools are missing** (`--fix` flag):
+   - Use suggested fixes from doctor command
+   - Follow up with `Skill("moai-foundation-langs")` to validate corrections
+
+3. **Debugging slash command issues** (`--check-commands`):
+   - Run `Skill("moai-cc-commands")` if commands fail to load
+   - Check `.claude/commands/` directory structure and permissions
+"""
+
+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")
+@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:
+    """Check system requirements and project health
+
+    Verifies:
+    - Python version (>= 3.13)
+    - Git installation
+    - Project structure (.moai directory)
+    - Language-specific tool chains (20+ languages)
+    """
+    try:
+        # Handle --check-commands option first
+        if check_commands:
+            _check_slash_commands()
+            return
+
+        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 with preferred package managers
+    install_commands = {
+        # Python tools (prefer uv)
+        "pytest": "uv pip install pytest",
+        "mypy": "uv pip install mypy",
+        "ruff": "uv pip install ruff",
+        # JavaScript tools
+        "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]")
+
+
+def _check_slash_commands() -> None:
+    """Check slash command loading issues (helper)"""
+    from moai_adk.core.diagnostics.slash_commands import diagnose_slash_commands
+
+    console.print("[cyan]Running slash command diagnostics...[/cyan]\n")
+
+    result = diagnose_slash_commands()
+
+    # Handle error case
+    if "error" in result:
+        console.print(f"[red]✗ {result['error']}[/red]")
+        return
+
+    # Build results table
+    table = Table(show_header=True, header_style="bold magenta")
+    table.add_column("Command File", style="dim", width=40)
+    table.add_column("Status", justify="center", width=10)
+    table.add_column("Issues", style="yellow")
+
+    for detail in result["details"]:
+        icon = "✓" if detail["valid"] else "✗"
+        color = "green" if detail["valid"] else "red"
+        issues = ", ".join(detail["errors"]) if detail["errors"] else "-"
+
+        table.add_row(detail["file"], f"[{color}]{icon}[/{color}]", issues)
+
+    console.print(table)
+    console.print()
+
+    # Summary
+    total = result["total_files"]
+    valid = result["valid_commands"]
+
+    if valid == total and total > 0:
+        console.print(f"[green]✓ {valid}/{total} command files are valid[/green]")
+    elif total == 0:
+        console.print("[yellow]⚠ No command files found in .claude/commands/[/yellow]")
+    else:
+        console.print(f"[yellow]⚠ Only {valid}/{total} command files are valid[/yellow]")
+        console.print("[dim]Fix the issues above to enable slash commands[/dim]")