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

moai_adk/cli/prompts/init_prompts.py

@@ -1,12 +1,11 @@
 """Project initialization prompts
 
-Collect interactive project settings
+Collect interactive project settings with modern UI.
 """
 
 from pathlib import Path
 from typing import TypedDict
 
-import questionary
 from rich.console import Console
 
 console = Console()
@@ -18,9 +17,8 @@ class ProjectSetupAnswers(TypedDict):
     project_name: str
     mode: str  # personal | team (default from init)
     locale: str  # ko | en | ja | zh | other (default from init)
-    language: str | None  # Will be set in /alfred:0-project
-    author: str  # Will be set in /alfred:0-project
-    mcp_servers: list[str]  # Selected MCP servers to install
+    language: str | None  # Will be set in /moai:0-project
+    author: str  # Will be set in /moai:0-project
     custom_language: str | None  # User input for "other" language option
 
 
@@ -30,7 +28,7 @@ def prompt_project_setup(
     project_path: Path | None = None,
     initial_locale: str | None = None,
 ) -> ProjectSetupAnswers:
-    """Project setup prompt
+    """Project setup prompt with modern UI.
 
     Args:
         project_name: Project name (asks when None)
@@ -46,29 +44,29 @@ def prompt_project_setup(
     """
     answers: ProjectSetupAnswers = {
         "project_name": "",
-        "mode": "personal",  # Default: will be configurable in /alfred:0-project
-        "locale": "en",  # Default: will be configurable in /alfred:0-project
-        "language": None,  # Will be detected in /alfred:0-project
-        "author": "",  # Will be set in /alfred:0-project
-        "mcp_servers": [],  # Selected MCP servers
+        "mode": "personal",  # Default: will be configurable in /moai:0-project
+        "locale": "en",  # Default: will be configurable in /moai:0-project
+        "language": None,  # Will be detected in /moai:0-project
+        "author": "",  # Will be set in /moai:0-project
         "custom_language": None,  # User input for other language
     }
 
     try:
         # SIMPLIFIED: Only ask for project name
-        # All other settings (mode, locale, language, author) are now configured in /alfred:0-project
+        # All other settings (mode, locale, language, author) are now configured in /moai:0-project
 
         # 1. Project name (only when not using the current directory)
         if not is_current_dir:
             if project_name:
                 answers["project_name"] = project_name
-                console.print(f"[cyan]📦 Project Name:[/cyan] {project_name}")
+                console.print(f"[#DA7756]📦 Project Name:[/#DA7756] {project_name}")
             else:
-                result = questionary.text(
+                # Try new UI, fallback to questionary
+                result = _prompt_text(
                     "📦 Project Name:",
                     default="my-moai-project",
-                    validate=lambda text: len(text) > 0 or "Project name is required",
-                ).ask()
+                    required=True,
+                )
                 if result is None:
                     raise KeyboardInterrupt
                 answers["project_name"] = result
@@ -81,7 +79,7 @@ def prompt_project_setup(
             else:
                 answers["project_name"] = Path.cwd().name  # fallback
             console.print(
-                f"[cyan]📦 Project Name:[/cyan] {answers['project_name']} [dim](current directory)[/dim]"
+                f"[#DA7756]📦 Project Name:[/#DA7756] {answers['project_name']} [dim](current directory)[/dim]"
             )
 
         # 2. Language selection - Korean, English, Japanese, Chinese, Other
@@ -89,75 +87,133 @@ def prompt_project_setup(
 
         # Build choices list
         language_choices = [
-            "한국어 (Korean)",
-            "English",
-            "日本語 (Japanese)",
-            "中文 (Chinese)",
-            "Other - Manual input",
+            {"name": "Korean (한국어)", "value": "ko"},
+            {"name": "English", "value": "en"},
+            {"name": "Japanese (日本語)", "value": "ja"},
+            {"name": "Chinese (中文)", "value": "zh"},
+            {"name": "Other - Manual input", "value": "other"},
         ]
 
-        # Determine default choice index
+        # Determine default
         language_values = ["ko", "en", "ja", "zh", "other"]
         default_locale = initial_locale or "en"
-        default_index = language_values.index(default_locale) if default_locale in language_values else 1
+        default_value = default_locale if default_locale in language_values else "en"
 
-        language_choice_name = questionary.select(
+        language_choice = _prompt_select(
             "Select your conversation language:",
             choices=language_choices,
-            default=language_choices[default_index],
-        ).ask()
-
-        # Map choice name back to value
-        choice_mapping = {
-            "한국어 (Korean)": "ko",
-            "English": "en",
-            "日本語 (Japanese)": "ja",
-            "中文 (Chinese)": "zh",
-            "Other - Manual input": "other",
-        }
-        language_choice = choice_mapping.get(language_choice_name)
+            default=default_value,
+        )
 
         if language_choice is None:
             raise KeyboardInterrupt
 
         if language_choice == "other":
             # Prompt for manual input
-            custom_lang = questionary.text(
+            custom_lang = _prompt_text(
                 "Enter your language:",
-                validate=lambda text: len(text) > 0 or "Language is required",
-            ).ask()
+                required=True,
+            )
 
             if custom_lang is None:
                 raise KeyboardInterrupt
 
             answers["custom_language"] = custom_lang
             answers["locale"] = "other"  # When ISO code is not available
-            console.print(f"[cyan]🌐 Selected Language:[/cyan] {custom_lang}")
+            console.print(f"[#DA7756]🌐 Selected Language:[/#DA7756] {custom_lang}")
         else:
             answers["locale"] = language_choice
             language_names = {
-                "ko": "한국어 (Korean)",
+                "ko": "Korean (한국어)",
                 "en": "English",
-                "ja": "日本語 (Japanese)",
-                "zh": "中文 (Chinese)",
+                "ja": "Japanese (日本語)",
+                "zh": "Chinese (中文)",
             }
             console.print(
-                f"[cyan]🌐 Selected Language:[/cyan] {language_names.get(language_choice, language_choice)}"
+                f"[#DA7756]🌐 Selected Language:[/#DA7756] {language_names.get(language_choice, language_choice)}"
             )
 
-        # Auto-install MCP servers
-        mcp_servers = ["context7", "playwright", "sequential-thinking"]
-        answers["mcp_servers"] = mcp_servers
-        console.print("\n[blue]🔧 MCP (Model Context Protocol) Configuration[/blue]")
-        console.print(
-            "[dim]Enhance AI capabilities with MCP servers (auto-installing recommended servers)[/dim]\n"
-        )
-        console.print(
-            f"[green]✅ MCP servers auto-installed: {', '.join(mcp_servers)}[/green]"
-        )
-
         return answers
 
     except KeyboardInterrupt:
         console.print("\n[yellow]Setup cancelled by user[/yellow]")
         raise
+
+
+def _prompt_text(
+    message: str,
+    default: str = "",
+    required: bool = False,
+) -> str | None:
+    """Display text input prompt with modern UI fallback.
+
+    Args:
+        message: Prompt message
+        default: Default value
+        required: Whether input is required
+
+    Returns:
+        User input or None if cancelled
+    """
+    try:
+        from moai_adk.cli.ui.prompts import styled_input
+
+        return styled_input(message, default=default, required=required)
+    except ImportError:
+        import questionary
+
+        if required:
+            result = questionary.text(
+                message,
+                default=default,
+                validate=lambda text: len(text) > 0 or "This field is required",
+            ).ask()
+        else:
+            result = questionary.text(message, default=default).ask()
+        return result
+
+
+def _prompt_select(
+    message: str,
+    choices: list[dict[str, str]],
+    default: str | None = None,
+) -> str | None:
+    """Display select prompt with modern UI fallback.
+
+    Args:
+        message: Prompt message
+        choices: List of choices with name and value
+        default: Default value
+
+    Returns:
+        Selected value or None if cancelled
+    """
+    try:
+        from moai_adk.cli.ui.prompts import styled_select
+
+        return styled_select(message, choices=choices, default=default)
+    except ImportError:
+        import questionary
+
+        # Map choices for questionary format
+        choice_names = [c["name"] for c in choices]
+        value_map = {c["name"]: c["value"] for c in choices}
+
+        # Find default name
+        default_name = None
+        if default:
+            for c in choices:
+                if c["value"] == default:
+                    default_name = c["name"]
+                    break
+
+        result_name = questionary.select(
+            message,
+            choices=choice_names,
+            default=default_name,
+        ).ask()
+
+        if result_name is None:
+            return None
+
+        return value_map.get(result_name)

moai_adk/cli/spec_status.py

@@ -0,0 +1,263 @@
+#!/usr/bin/env python3
+"""Spec Status Manager CLI Tool
+
+Provides command-line interface for managing SPEC status tracking.
+
+Usage:
+    python3 -m moai_adk.cli.spec_status <command> <spec_id> [options]
+    moai-spec <command> <spec_id> [options]
+
+Commands:
+    - status_update: Update SPEC status
+    - validate_completion: Validate if SPEC is ready for completion
+    - batch_update: Update all completed SPECs
+"""
+
+import argparse
+import json
+import sys
+from datetime import datetime
+from pathlib import Path
+from typing import Any, Dict
+
+try:
+    from moai_adk.core.spec_status_manager import SpecStatusManager
+except ImportError:
+    # Fallback: look in current directory
+    import sys
+    from pathlib import Path
+
+    sys.path.insert(0, str(Path(__file__).parent.parent))
+    try:
+        from core.spec_status_manager import SpecStatusManager  # type: ignore[no-redef]
+    except ImportError:
+        raise ImportError("SpecStatusManager not found")
+
+
+def update_spec_status(spec_id: str, new_status: str, reason: str = "") -> Dict[str, Any]:
+    """Update SPEC status with validation and logging
+
+    Args:
+        spec_id: The SPEC identifier
+        new_status: New status value
+        reason: Reason for status change
+
+    Returns:
+        Update result dictionary
+    """
+    try:
+        # Initialize manager
+        project_root = Path.cwd()
+        manager = SpecStatusManager(project_root)
+
+        # Validate new status
+        valid_statuses = ["draft", "in-progress", "completed", "archived"]
+        if new_status not in valid_statuses:
+            return {
+                "success": False,
+                "error": f"Invalid status: {new_status}. Valid statuses: {valid_statuses}",
+            }
+
+        # Check if SPEC exists
+        spec_file = project_root / ".moai" / "specs" / spec_id / "spec.md"
+        if not spec_file.exists():
+            return {"success": False, "error": f"SPEC file not found: {spec_file}"}
+
+        # Update status
+        success = manager.update_spec_status(spec_id, new_status)
+
+        if success:
+            # Log the status change
+            log_entry = {
+                "timestamp": datetime.now().isoformat(),
+                "spec_id": spec_id,
+                "old_status": "unknown",  # Could be extracted from file before update
+                "new_status": new_status,
+                "reason": reason,
+            }
+
+            # Create status change log
+            log_dir = project_root / ".moai" / "logs"
+            log_dir.mkdir(parents=True, exist_ok=True)
+            log_file = log_dir / "spec_status_changes.jsonl"
+
+            with open(log_file, "a", encoding="utf-8") as f:
+                f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
+
+            return {
+                "success": True,
+                "spec_id": spec_id,
+                "new_status": new_status,
+                "reason": reason,
+                "timestamp": log_entry["timestamp"],
+            }
+        else:
+            return {
+                "success": False,
+                "error": f"Failed to update SPEC {spec_id} status",
+            }
+
+    except Exception as e:
+        return {"success": False, "error": f"Error updating SPEC status: {str(e)}"}
+
+
+def validate_spec_completion(spec_id: str) -> Dict[str, Any]:
+    """Validate if SPEC is ready for completion
+
+    Args:
+        spec_id: The SPEC identifier
+
+    Returns:
+        Validation result dictionary
+    """
+    try:
+        project_root = Path.cwd()
+        manager = SpecStatusManager(project_root)
+
+        # Run validation
+        validation = manager.validate_spec_for_completion(spec_id)
+
+        return {"success": True, "spec_id": spec_id, "validation": validation}
+
+    except Exception as e:
+        return {
+            "success": False,
+            "error": f"Error validating SPEC completion: {str(e)}",
+        }
+
+
+def batch_update_completed_specs() -> Dict[str, Any]:
+    """Batch update all draft SPECs that have completed implementations
+
+    Returns:
+        Batch update result dictionary
+    """
+    try:
+        project_root = Path.cwd()
+        manager = SpecStatusManager(project_root)
+
+        # Run batch update
+        results = manager.batch_update_completed_specs()
+
+        # Log the batch update
+        log_entry = {
+            "timestamp": datetime.now().isoformat(),
+            "operation": "batch_update_completed",
+            "results": results,
+        }
+
+        log_dir = project_root / ".moai" / "logs"
+        log_dir.mkdir(parents=True, exist_ok=True)
+        log_file = log_dir / "spec_status_changes.jsonl"
+
+        with open(log_file, "a", encoding="utf-8") as f:
+            f.write(json.dumps(log_entry, ensure_ascii=False) + "\n")
+
+        return {
+            "success": True,
+            "results": results,
+            "timestamp": log_entry["timestamp"],
+        }
+
+    except Exception as e:
+        return {"success": False, "error": f"Error in batch update: {str(e)}"}
+
+
+def detect_draft_specs() -> Dict[str, Any]:
+    """Detect all draft SPECs in the project
+
+    Returns:
+        List of draft SPEC IDs
+    """
+    try:
+        project_root = Path.cwd()
+        manager = SpecStatusManager(project_root)
+
+        draft_specs = manager.detect_draft_specs()
+
+        return {
+            "success": True,
+            "draft_specs": list(draft_specs),
+            "count": len(draft_specs),
+        }
+
+    except Exception as e:
+        return {"success": False, "error": f"Error detecting draft SPECs: {str(e)}"}
+
+
+def main():
+    """Main function"""
+    parser = argparse.ArgumentParser(description="Spec Status Manager Hooks")
+    parser.add_argument(
+        "command",
+        choices=[
+            "status_update",
+            "validate_completion",
+            "batch_update",
+            "detect_drafts",
+        ],
+        help="Command to execute",
+    )
+    parser.add_argument("spec_id", nargs="?", help="SPEC ID (for specific commands)")
+    parser.add_argument("--status", help="New status value")
+    parser.add_argument("--reason", default="", help="Reason for status change")
+
+    args = parser.parse_args()
+
+    try:
+        result = {}
+
+        if args.command == "status_update":
+            if not args.spec_id or not args.status:
+                print(
+                    json.dumps(
+                        {
+                            "success": False,
+                            "error": "status_update requires spec_id and --status",
+                        }
+                    )
+                )
+                sys.exit(1)
+
+            result = update_spec_status(args.spec_id, args.status, args.reason)
+
+        elif args.command == "validate_completion":
+            if not args.spec_id:
+                print(
+                    json.dumps(
+                        {
+                            "success": False,
+                            "error": "validate_completion requires spec_id",
+                        }
+                    )
+                )
+                sys.exit(1)
+
+            result = validate_spec_completion(args.spec_id)
+
+        elif args.command == "batch_update":
+            result = batch_update_completed_specs()
+
+        elif args.command == "detect_drafts":
+            result = detect_draft_specs()
+
+        # Add command info
+        result["command"] = args.command
+        result["execution_time"] = datetime.now().isoformat()
+
+        print(json.dumps(result, ensure_ascii=False, indent=2))
+
+    except Exception as e:
+        error_result = {
+            "success": False,
+            "command": args.command if "args" in locals() else "unknown",
+            "error": str(e),
+            "execution_time": datetime.now().isoformat(),
+        }
+
+        print(json.dumps(error_result, ensure_ascii=False, indent=2))
+        sys.exit(1)
+
+
+if __name__ == "__main__":
+    main()

moai_adk/cli/ui/__init__.py

@@ -0,0 +1,44 @@
+"""MoAI-ADK CLI UI Components
+
+Modern, user-friendly CLI interface components using InquirerPy and Rich.
+
+Provides:
+- Fuzzy search checkbox prompts
+- Progress indicators (bars, spinners)
+- Styled text input and selection prompts
+- Consistent theming across all CLI commands
+"""
+
+from .progress import (
+    ProgressContext,
+    SpinnerContext,
+    create_progress_bar,
+    create_spinner,
+)
+from .prompts import (
+    fuzzy_checkbox,
+    fuzzy_select,
+    styled_checkbox,
+    styled_confirm,
+    styled_input,
+    styled_select,
+)
+from .theme import MOAI_THEME, get_styled_choice
+
+__all__ = [
+    # Prompts
+    "fuzzy_checkbox",
+    "fuzzy_select",
+    "styled_checkbox",
+    "styled_confirm",
+    "styled_input",
+    "styled_select",
+    # Progress
+    "ProgressContext",
+    "SpinnerContext",
+    "create_progress_bar",
+    "create_spinner",
+    # Theme
+    "MOAI_THEME",
+    "get_styled_choice",
+]