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

moai_adk/cli/main.py

@@ -1,4 +1,3 @@
-# @CODE:PY314-001 | SPEC: SPEC-PY314-001.md | TEST: tests/unit/test_commands.py
 """CLI Main Module
 
 CLI entry module:
@@ -7,6 +6,8 @@ CLI entry module:
 - Rich console terminal output
 """
 
-from moai_adk.__main__ import cli, show_logo
+# type: ignore
+
+from moai_adk.__main__ import cli, show_logo  # type: ignore[attr-defined]
 
 __all__ = ["cli", "show_logo"]

moai_adk/cli/prompts/init_prompts.py

@@ -1,13 +1,11 @@
-# @CODE:CLI-PROMPTS-001 | SPEC: SPEC-CLI-001/spec.md
 """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()
@@ -17,10 +15,11 @@ class ProjectSetupAnswers(TypedDict):
     """Project setup answers"""
 
     project_name: str
-    mode: str  # personal | team
-    locale: str  # ko | en
-    language: str | None
-    author: 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 /moai:0-project
+    author: str  # Will be set in /moai:0-project
+    custom_language: str | None  # User input for "other" language option
 
 
 def prompt_project_setup(
@@ -29,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)
@@ -45,24 +44,29 @@ def prompt_project_setup(
     """
     answers: ProjectSetupAnswers = {
         "project_name": "",
-        "mode": "personal",
-        "locale": "ko",
-        "language": None,
-        "author": "",
+        "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 /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
@@ -75,92 +79,141 @@ 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. Project mode
-        result = questionary.select(
-            "🔧 Project Mode:",
-            choices=[
-                questionary.Choice("Personal (single developer)", value="personal"),
-                questionary.Choice("Team (collaborative)", value="team"),
-            ],
-            default="personal",
-        ).ask()
-        if result is None:
+        # 2. Language selection - Korean, English, Japanese, Chinese, Other
+        console.print("\n[blue]🌐 Language Selection[/blue]")
+
+        # Build choices list
+        language_choices = [
+            {"name": "Korean (한국어)", "value": "ko"},
+            {"name": "English", "value": "en"},
+            {"name": "Japanese (日本語)", "value": "ja"},
+            {"name": "Chinese (中文)", "value": "zh"},
+            {"name": "Other - Manual input", "value": "other"},
+        ]
+
+        # Determine default
+        language_values = ["ko", "en", "ja", "zh", "other"]
+        default_locale = initial_locale or "en"
+        default_value = default_locale if default_locale in language_values else "en"
+
+        language_choice = _prompt_select(
+            "Select your conversation language:",
+            choices=language_choices,
+            default=default_value,
+        )
+
+        if language_choice is None:
             raise KeyboardInterrupt
-        answers["mode"] = result
-        answers["locale"] = initial_locale or "en"
-        if initial_locale:
-            console.print(
-                f"[cyan]🌐 Preferred Language:[/cyan] {answers['locale']} (specified via CLI option)"
+
+        if language_choice == "other":
+            # Prompt for manual input
+            custom_lang = _prompt_text(
+                "Enter your language:",
+                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"[#DA7756]🌐 Selected Language:[/#DA7756] {custom_lang}")
         else:
+            answers["locale"] = language_choice
+            language_names = {
+                "ko": "Korean (한국어)",
+                "en": "English",
+                "ja": "Japanese (日本語)",
+                "zh": "Chinese (中文)",
+            }
             console.print(
-                "[cyan]🌐 Preferred Language:[/cyan] en (default, changeable in /alfred:0-project)"
+                f"[#DA7756]🌐 Selected Language:[/#DA7756] {language_names.get(language_choice, language_choice)}"
             )
 
-        # 3. Programming language (auto-detect or manual)
-        result = questionary.confirm(
-            "🔍 Auto-detect programming language?",
-            default=True,
-        ).ask()
-        if result is None:
-            raise KeyboardInterrupt
-        detect_language = result
-
-        if not detect_language:
-            result = questionary.select(
-                "💻 Select programming language:",
-                choices=[
-                    "Python",
-                    "TypeScript",
-                    "JavaScript",
-                    "Java",
-                    "Go",
-                    "Rust",
-                    "Ruby",
-                    "Dart",
-                    "Swift",
-                    "Kotlin",
-                    "PHP",
-                    "C#",
-                    "C",
-                    "C++",
-                    "Elixir",
-                    "Scala",
-                    "Clojure",
-                    "Haskell",
-                    "Lua",
-                    "OCaml",
-                    "Generic",
-                ],
-            ).ask()
-            if result is None:
-                raise KeyboardInterrupt
-            answers["language"] = result
+        return answers
 
-        # 4. Author information (optional)
-        result = questionary.confirm(
-            "👤 Add author information? (optional)",
-            default=False,
-        ).ask()
-        if result is None:
-            raise KeyboardInterrupt
-        add_author = result
+    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
 
-        if add_author:
+    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(
-                "Author (GitHub ID):",
-                default="",
-                validate=lambda text: text.startswith("@") or "Must start with @",
+                message,
+                default=default,
+                validate=lambda text: len(text) > 0 or "This field is required",
             ).ask()
-            if result is None:
-                raise KeyboardInterrupt
-            answers["author"] = result
+        else:
+            result = questionary.text(message, default=default).ask()
+        return result
 
-        return answers
 
-    except KeyboardInterrupt:
-        console.print("\n[yellow]Setup cancelled by user[/yellow]")
-        raise
+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",
+]