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

moai_adk/cli/ui/prompts.py

@@ -0,0 +1,389 @@
+"""MoAI-ADK CLI Prompt Components
+
+Modern interactive prompts using InquirerPy with fuzzy search support.
+"""
+
+from typing import Any, Callable, Dict, List, Optional, Sequence, Union
+
+from InquirerPy import inquirer
+from InquirerPy.base.control import Choice, Separator
+from InquirerPy.utils import get_style
+from InquirerPy.validator import EmptyInputValidator
+
+from .theme import MOAI_THEME, SYMBOLS
+
+# Pre-create InquirerPy compatible style
+_INQUIRER_STYLE = get_style(MOAI_THEME, style_override=False)
+
+
+def fuzzy_checkbox(
+    message: str,
+    choices: Sequence[Union[str, Dict[str, Any], Choice, Separator]],
+    default: Optional[List[Any]] = None,
+    instruction: str = "[Space] Toggle  [Tab] Toggle All  [Enter] Confirm  [/] Search",
+    multiselect: bool = True,
+    marker: str = SYMBOLS["checkbox_selected"],  # type: ignore[assignment]
+    marker_pl: str = " ",
+    border: bool = True,
+    height: Optional[int] = None,
+    max_height: int = 15,
+    validate: Optional[Callable[[List[Any]], bool]] = None,
+    invalid_message: str = "Please select at least one item",
+    keybindings: Optional[Dict[str, List[Dict[str, str]]]] = None,
+) -> Optional[List[Any]]:
+    """Display a fuzzy searchable checkbox prompt.
+
+    Allows users to search through choices while selecting multiple items.
+    Perfect for selecting files from a large list.
+
+    Args:
+        message: Question to display
+        choices: List of choices (strings, dicts, or Choice objects)
+        default: Pre-selected values
+        instruction: Help text shown below prompt
+        multiselect: Allow multiple selections (always True for checkbox)
+        marker: Symbol for selected items
+        marker_pl: Placeholder for unselected items
+        border: Show border around choices
+        height: Fixed height (None for auto)
+        max_height: Maximum height when auto
+        validate: Custom validation function
+        invalid_message: Message when validation fails
+        keybindings: Custom key bindings
+
+    Returns:
+        List of selected values, or None if cancelled
+
+    Example:
+        >>> files = fuzzy_checkbox(
+        ...     "Select files to restore:",
+        ...     choices=[
+        ...         {"name": "commands/auth.md", "value": "commands/auth.md"},
+        ...         {"name": "agents/backend.md", "value": "agents/backend.md"},
+        ...     ]
+        ... )
+    """
+    # Convert simple strings to Choice objects
+    processed_choices = _process_choices(list(choices), default)
+
+    # Set up default keybindings if not provided
+    if keybindings is None:
+        keybindings = {
+            "toggle": [{"key": "space"}],
+            "toggle-all": [{"key": "tab"}],
+            "toggle-all-true": [{"key": "a"}],
+            "toggle-all-false": [{"key": "n"}],
+        }
+
+    try:
+        result = inquirer.fuzzy(
+            message=message,
+            choices=processed_choices,
+            multiselect=multiselect,
+            marker=marker,
+            marker_pl=marker_pl,
+            border=border,
+            info=True,
+            match_exact=False,
+            instruction=instruction,
+            long_instruction="",
+            max_height=max_height if height is None else height,
+            validate=validate,
+            invalid_message=invalid_message,
+            keybindings=keybindings,  # type: ignore[arg-type]
+            style=_INQUIRER_STYLE,
+            qmark=SYMBOLS["pointer"],
+            amark=SYMBOLS["success"],
+            transformer=lambda x: f"{len(x)} selected" if isinstance(x, list) else x,
+        ).execute()
+
+        return result
+
+    except KeyboardInterrupt:
+        return None
+
+
+def fuzzy_select(
+    message: str,
+    choices: Sequence[Union[str, Dict[str, Any], Choice, Separator]],
+    default: Optional[Any] = None,
+    instruction: str = "[↑↓] Navigate  [Enter] Select  [/] Search",
+    border: bool = True,
+    max_height: int = 10,
+) -> Optional[Any]:
+    """Display a fuzzy searchable single-select prompt.
+
+    Args:
+        message: Question to display
+        choices: List of choices
+        default: Pre-selected value
+        instruction: Help text
+        border: Show border around choices
+        max_height: Maximum display height
+
+    Returns:
+        Selected value, or None if cancelled
+    """
+    processed_choices = _process_choices(list(choices), [default] if default else None)
+
+    try:
+        result = inquirer.fuzzy(
+            message=message,
+            choices=processed_choices,
+            multiselect=False,
+            border=border,
+            info=True,
+            match_exact=False,
+            instruction=instruction,
+            max_height=max_height,
+            style=_INQUIRER_STYLE,
+            qmark=SYMBOLS["pointer"],
+            amark=SYMBOLS["success"],
+        ).execute()
+
+        return result
+
+    except KeyboardInterrupt:
+        return None
+
+
+def styled_checkbox(
+    message: str,
+    choices: Sequence[Union[str, Dict[str, Any], Choice, Separator]],
+    default: Optional[List[Any]] = None,
+    instruction: str = "[Space] Toggle  [a] All  [n] None  [Enter] Confirm",
+    cycle: bool = True,
+) -> Optional[List[Any]]:
+    """Display a styled checkbox prompt without fuzzy search.
+
+    Use this for shorter lists where fuzzy search isn't needed.
+
+    Args:
+        message: Question to display
+        choices: List of choices
+        default: Pre-selected values
+        instruction: Help text
+        cycle: Whether to cycle through choices
+
+    Returns:
+        List of selected values, or None if cancelled
+    """
+    processed_choices = _process_choices(list(choices), default)
+
+    try:
+        result = inquirer.checkbox(
+            message=message,
+            choices=processed_choices,
+            cycle=cycle,
+            instruction=instruction,
+            style=_INQUIRER_STYLE,
+            qmark=SYMBOLS["pointer"],
+            amark=SYMBOLS["success"],
+            enabled_symbol=SYMBOLS["checkbox_selected"],
+            disabled_symbol=SYMBOLS["checkbox_unselected"],
+            transformer=lambda x: f"{len(x)} selected" if isinstance(x, list) else x,
+        ).execute()
+
+        return result
+
+    except KeyboardInterrupt:
+        return None
+
+
+def styled_select(
+    message: str,
+    choices: Sequence[Union[str, Dict[str, Any], Choice, Separator]],
+    default: Optional[Any] = None,
+    instruction: str = "[↑↓] Navigate  [Enter] Select",
+    cycle: bool = True,
+) -> Optional[Any]:
+    """Display a styled single-select prompt.
+
+    Args:
+        message: Question to display
+        choices: List of choices
+        default: Pre-selected value
+        instruction: Help text
+        cycle: Whether to cycle through choices
+
+    Returns:
+        Selected value, or None if cancelled
+    """
+    processed_choices = _process_choices(list(choices), [default] if default else None)
+
+    try:
+        result = inquirer.select(
+            message=message,
+            choices=processed_choices,
+            default=default,
+            cycle=cycle,
+            instruction=instruction,
+            style=_INQUIRER_STYLE,
+            qmark=SYMBOLS["pointer"],
+            amark=SYMBOLS["success"],
+            pointer=SYMBOLS["pointer"],
+        ).execute()
+
+        return result
+
+    except KeyboardInterrupt:
+        return None
+
+
+def styled_input(
+    message: str,
+    default: str = "",
+    validate: Optional[Callable[[str], bool]] = None,
+    invalid_message: str = "Invalid input",
+    required: bool = True,
+    instruction: str = "",
+) -> Optional[str]:
+    """Display a styled text input prompt.
+
+    Args:
+        message: Question to display
+        default: Default value
+        validate: Custom validation function
+        invalid_message: Message when validation fails
+        required: Whether input is required
+        instruction: Help text
+
+    Returns:
+        User input, or None if cancelled
+    """
+    validators = []
+    if required:
+        validators.append(EmptyInputValidator("This field is required"))
+
+    try:
+        result = inquirer.text(
+            message=message,
+            default=default,
+            validate=validate,
+            invalid_message=invalid_message,
+            instruction=instruction,
+            style=_INQUIRER_STYLE,
+            qmark=SYMBOLS["pointer"],
+            amark=SYMBOLS["success"],
+        ).execute()
+
+        return result
+
+    except KeyboardInterrupt:
+        return None
+
+
+def styled_confirm(
+    message: str,
+    default: bool = True,
+    instruction: str = "[y/n]",
+) -> Optional[bool]:
+    """Display a styled confirmation prompt.
+
+    Args:
+        message: Question to display
+        default: Default value (True = yes, False = no)
+        instruction: Help text
+
+    Returns:
+        True/False, or None if cancelled
+    """
+    try:
+        result = inquirer.confirm(
+            message=message,
+            default=default,
+            instruction=instruction,
+            style=_INQUIRER_STYLE,
+            qmark=SYMBOLS["pointer"],
+            amark=SYMBOLS["success"],
+        ).execute()
+
+        return result
+
+    except KeyboardInterrupt:
+        return None
+
+
+def _process_choices(
+    choices: List[Union[str, Dict[str, Any], Choice, Separator]],
+    defaults: Optional[List[Any]] = None,
+) -> List[Union[Choice, Separator]]:
+    """Process and normalize choices for InquirerPy prompts.
+
+    Args:
+        choices: Raw choices list
+        defaults: Values that should be pre-selected
+
+    Returns:
+        List of Choice/Separator objects
+    """
+    defaults = defaults or []
+    processed: List[Union[Choice, Separator]] = []
+
+    for choice in choices:
+        if isinstance(choice, (Choice, Separator)):
+            # Already a Choice or Separator object
+            processed.append(choice)
+
+        elif isinstance(choice, dict):
+            # Dictionary with name/value
+            name = choice.get("name", choice.get("title", ""))
+            value = choice.get("value", name)
+            enabled = choice.get("enabled", value in defaults)
+            disabled = choice.get("disabled", False)
+
+            if disabled:
+                # Create a separator for disabled items
+                processed.append(Separator(line=name))
+            else:
+                processed.append(Choice(value=value, name=name, enabled=enabled))
+
+        elif isinstance(choice, str):
+            # Simple string
+            enabled = choice in defaults
+            processed.append(Choice(value=choice, name=choice, enabled=enabled))
+
+    return processed
+
+
+def create_grouped_choices(
+    groups: Dict[str, List[Dict[str, Any]]],
+    defaults: Optional[List[Any]] = None,
+) -> List[Union[Choice, Separator]]:
+    """Create grouped choices with separators for each category.
+
+    Args:
+        groups: Dictionary mapping category names to lists of choices
+        defaults: Values that should be pre-selected
+
+    Returns:
+        List of choices with category separators
+
+    Example:
+        >>> choices = create_grouped_choices({
+        ...     "Commands": [
+        ...         {"name": "auth.md", "value": "commands/auth.md"},
+        ...         {"name": "deploy.md", "value": "commands/deploy.md"},
+        ...     ],
+        ...     "Agents": [
+        ...         {"name": "backend.md", "value": "agents/backend.md"},
+        ...     ],
+        ... })
+    """
+    defaults = defaults or []
+    result: List[Union[Choice, Separator]] = []
+
+    for category, items in groups.items():
+        if items:  # Only add category if it has items
+            # Add category separator
+            result.append(Separator(line=f"── {category} ──"))
+
+            # Add items in this category
+            for item in items:
+                name = item.get("name", item.get("title", ""))
+                value = item.get("value", name)
+                enabled = item.get("enabled", value in defaults)
+
+                result.append(Choice(value=value, name=f"  {name}", enabled=enabled))
+
+    return result

moai_adk/cli/ui/theme.py

@@ -0,0 +1,129 @@
+"""MoAI-ADK CLI Theme Configuration
+
+Consistent styling for all CLI components using InquirerPy custom styles.
+"""
+
+from typing import Any, Dict, Optional
+
+from rich.console import Console
+
+_console = Console()
+
+# Claude Code official colors + MoAI theme
+MOAI_COLORS = {
+    "primary": "#DA7756",  # Claude Code terra cotta - main brand color
+    "secondary": "#10B981",  # Green - success/selected
+    "accent": "#DA7756",  # Claude Code terra cotta - highlights
+    "info": "#3B82F6",  # Blue - information
+    "warning": "#F59E0B",  # Amber - warnings
+    "error": "#EF4444",  # Red - errors
+    "muted": "#6B7280",  # Gray - secondary text
+    "text": "#E5E7EB",  # Light gray - primary text
+    "claude_terra": "#DA7756",  # Claude Code official terra cotta
+    "claude_black": "#000000",  # Claude Code official black
+}
+
+# InquirerPy style configuration
+MOAI_THEME: Dict[str, str] = {
+    # Question styling
+    "questionmark": f"fg:{MOAI_COLORS['primary']} bold",
+    "question": "bold",
+    "answered_question": "",
+    "answer": f"fg:{MOAI_COLORS['secondary']} bold",
+    "input": f"fg:{MOAI_COLORS['text']}",
+    "instruction": f"fg:{MOAI_COLORS['muted']}",
+    # Pointer and marker styling
+    "pointer": f"fg:{MOAI_COLORS['primary']} bold",
+    "checkbox": f"fg:{MOAI_COLORS['primary']}",
+    "selected": f"fg:{MOAI_COLORS['secondary']}",
+    "separator": f"fg:{MOAI_COLORS['muted']}",
+    # Fuzzy prompt styling
+    "fuzzy_prompt": f"fg:{MOAI_COLORS['primary']}",
+    "fuzzy_info": f"fg:{MOAI_COLORS['muted']}",
+    "fuzzy_border": f"fg:{MOAI_COLORS['muted']}",
+    "fuzzy_match": f"fg:{MOAI_COLORS['accent']} bold",
+    # Validator styling
+    "validator": "",
+    "marker": f"fg:{MOAI_COLORS['secondary']}",
+    "long_instruction": f"fg:{MOAI_COLORS['muted']}",
+    # Skipped question styling
+    "skipped": f"fg:{MOAI_COLORS['muted']}",
+}
+
+# Symbols for consistent UI (string symbols only for InquirerPy)
+SYMBOLS: Dict[str, str] = {
+    "checkbox_selected": "●",  # Filled circle for selected
+    "checkbox_unselected": "○",  # Empty circle for unselected
+    "pointer": "❯",  # Arrow pointer
+    "success": "✓",
+    "error": "✗",
+    "warning": "⚠",
+    "info": "ℹ",
+}
+
+# Spinner frames for Rich progress indicators
+SPINNER_FRAMES = ["⠋", "⠙", "⠹", "⠸", "⠼", "⠴", "⠦", "⠧", "⠇", "⠏"]
+
+
+def get_styled_choice(
+    title: str,
+    value: Any,
+    enabled: bool = False,
+    description: Optional[str] = None,
+) -> Dict[str, Any]:
+    """Create a styled choice for InquirerPy prompts.
+
+    Args:
+        title: Display text for the choice
+        value: Value returned when selected
+        enabled: Whether pre-selected (for checkbox)
+        description: Optional description shown below title
+
+    Returns:
+        Dictionary suitable for InquirerPy Choice
+    """
+    choice: Dict[str, Any] = {
+        "name": title,
+        "value": value,
+        "enabled": enabled,
+    }
+
+    if description:
+        # Append description in muted color
+        choice["name"] = f"{title}\n  {description}"
+
+    return choice
+
+
+def print_styled(
+    message: str,
+    style: str = "text",
+    bold: bool = False,
+    newline: bool = True,
+) -> None:
+    """Print styled text using MoAI theme colors.
+
+    Args:
+        message: Text to print
+        style: One of 'primary', 'secondary', 'accent', 'info', 'warning', 'error', 'muted', 'text'
+        bold: Whether to make text bold
+        newline: Whether to add newline after message
+    """
+    color = MOAI_COLORS.get(style, MOAI_COLORS["text"])
+    rich_style = f"[{color}]"
+    if bold:
+        rich_style = f"[bold {color}]"
+
+    _console.print(f"{rich_style}{message}[/]", end="\n" if newline else "")
+
+
+def get_category_separator(category: str) -> Dict[str, Any]:
+    """Create a styled category separator for grouping choices.
+
+    Args:
+        category: Category name to display
+
+    Returns:
+        Separator dictionary for InquirerPy
+    """
+    return {"value": None, "name": f"── {category} ──", "disabled": True}

moai_adk/cli/worktree/__init__.py

@@ -0,0 +1,27 @@
+"""Git Worktree CLI module for parallel SPEC development."""
+
+from moai_adk.cli.worktree.exceptions import (
+    GitOperationError,
+    MergeConflictError,
+    RegistryInconsistencyError,
+    UncommittedChangesError,
+    WorktreeError,
+    WorktreeExistsError,
+    WorktreeNotFoundError,
+)
+from moai_adk.cli.worktree.manager import WorktreeManager
+from moai_adk.cli.worktree.models import WorktreeInfo
+from moai_adk.cli.worktree.registry import WorktreeRegistry
+
+__all__ = [
+    "WorktreeManager",
+    "WorktreeRegistry",
+    "WorktreeInfo",
+    "WorktreeError",
+    "WorktreeExistsError",
+    "WorktreeNotFoundError",
+    "UncommittedChangesError",
+    "GitOperationError",
+    "MergeConflictError",
+    "RegistryInconsistencyError",
+]

moai_adk/cli/worktree/__main__.py

@@ -0,0 +1,31 @@
+"""Standalone CLI entry point for moai-worktree command
+
+This module provides a standalone entry point for the moai-worktree CLI,
+allowing users to invoke worktree commands directly via `moai-worktree`
+instead of `moai-adk worktree`.
+
+Usage:
+    moai-worktree new SPEC-001
+    moai-worktree list
+    moai-worktree go SPEC-001
+    etc.
+"""
+
+import sys
+
+# Import the worktree CLI group from the main module
+from moai_adk.cli.worktree.cli import worktree
+
+
+def main() -> int:
+    """Standalone entry point for moai-worktree CLI"""
+    try:
+        worktree(standalone_mode=False)
+        return 0
+    except Exception as e:
+        print(f"Error: {e}", file=sys.stderr)
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())