moai-adk 0.8.0__py3-none-any.whl → 0.34.0__py3-none-any.whl

moai_adk/templates/.claude/skills/moai-workflow-project/modules/advanced-patterns.md

@@ -0,0 +1,158 @@
+# Advanced Implementation Patterns
+
+Advanced patterns for custom template development, performance optimization, and integration workflows.
+
+## Custom Template Development
+
+Documentation Templates:
+```python
+# Custom template for specific project type
+custom_template = {
+ "project_type": "mobile_application",
+ "language": "ko",
+ "sections": {
+ "product": {
+ "mission": " ",
+ "metrics": [" ", " ", " "],
+ "success_criteria": " "
+ },
+ "tech": {
+ "frameworks": ["Flutter", "React Native", "Swift"],
+ "performance_targets": " "
+ }
+ }
+}
+
+# Generate custom documentation
+docs = project.documentation_manager._generate_product_doc(
+ "mobile_application", "ko"
+)
+```
+
+Language-Specific Customization:
+```python
+# Add custom language support
+custom_language_config = {
+ "code": "de",
+ "name": "German",
+ "native_name": "Deutsch",
+ "locale": "de_DE.UTF-8",
+ "date_format": "%d.%m.%Y",
+ "rtl": False
+}
+
+# Register custom language
+project.language_initializer.LANGUAGE_CONFIG["de"] = custom_language_config
+```
+
+## Performance Optimization Strategies
+
+Template Caching:
+```python
+# Enable template caching for performance
+project.template_optimizer.optimization_cache = {}
+
+# Cache optimization results
+def cached_optimization(template_path):
+ cache_key = f"opt_{template_path}_{datetime.now().strftime('%Y%m%d')}"
+ 
+ if cache_key not in project.template_optimizer.optimization_cache:
+ result = project.template_optimizer._optimize_template_file(template_path)
+ project.template_optimizer.optimization_cache[cache_key] = result
+ 
+ return project.template_optimizer.optimization_cache[cache_key]
+```
+
+Batch Processing:
+```python
+# Process multiple templates efficiently
+def batch_optimize_templates(template_paths):
+ results = []
+ 
+ for template_path in template_paths:
+ try:
+ result = project.template_optimizer._optimize_template_file(template_path)
+ results.append(result)
+ except Exception as e:
+ results.append({
+ "file_path": template_path,
+ "success": False,
+ "error": str(e)
+ })
+ 
+ return results
+```
+
+## Integration Workflows
+
+Complete Project Lifecycle:
+```python
+def full_project_lifecycle():
+ """Complete project setup and management workflow."""
+ 
+ # Phase 1: Project Initialization
+ project = MoaiMenuProject("./new-project")
+ init_result = project.initialize_complete_project(
+ language="en",
+ domains=["backend", "frontend"],
+ optimization_enabled=True
+ )
+ 
+ # Phase 2: Feature Development with SPEC
+ spec_data = {
+ "id": "SPEC-001",
+ "title": "Core Feature Implementation",
+ "requirements": ["Requirement 1", "Requirement 2"],
+ "api_endpoints": [/* ... */]
+ }
+ 
+ docs_result = project.generate_documentation_from_spec(spec_data)
+ 
+ # Phase 3: Performance Optimization
+ optimization_result = project.optimize_project_templates()
+ 
+ # Phase 4: Documentation Export
+ export_result = project.export_project_documentation("html")
+ 
+ # Phase 5: Backup Creation
+ backup_result = project.create_project_backup()
+ 
+ return {
+ "initialization": init_result,
+ "documentation": docs_result,
+ "optimization": optimization_result,
+ "export": export_result,
+ "backup": backup_result
+ }
+```
+
+Multilingual Project Management:
+```python
+def multilingual_project_workflow():
+ """Manage multilingual project with cost optimization."""
+ 
+ project = MoaiMenuProject("./multilingual-project")
+ 
+ # Initialize with primary language
+ init_result = project.initialize_complete_project(
+ language="ko",
+ user_name=" ",
+ domains=["backend", "frontend"]
+ )
+ 
+ # Optimize agent prompts for cost (use English)
+ lang_update = project.update_language_settings({
+ "language.agent_prompt_language": "english"
+ })
+ 
+ # Generate documentation in multiple languages
+ for lang in ["ko", "en", "ja"]:
+ export_result = project.export_project_documentation("markdown", lang)
+ print(f"{lang} documentation exported: {export_result['success']}")
+ 
+ return init_result
+```
+
+---
+
+For detailed implementation patterns, refer to the main SKILL.md Implementation Guide section.

moai_adk/templates/.claude/skills/moai-workflow-project/modules/ask_user_integration.py

@@ -0,0 +1,340 @@
+"""
+AskUserQuestion Integration Module
+
+Provides seamless integration between the BatchQuestionsManager and Claude Code's
+AskUserQuestion functionality, ensuring consistent user interaction patterns
+across all MoAI skills.
+
+Author: MoAI-ADK
+Version: 1.0.0
+"""
+
+import logging
+from dataclasses import dataclass, field
+from typing import Any, Dict, List, Optional, Union
+
+from .batch_questions import BatchQuestionsManager, Question, QuestionType, UserResponse
+
+logger = logging.getLogger(__name__)
+
+
+@dataclass
+class AskUserConfig:
+    """Configuration for AskUserQuestion integration."""
+
+    max_options_per_question: int = 10
+    enable_descriptions: bool = True
+    enable_conditional: bool = True
+    validation_error_retries: int = 3
+    timeout_seconds: Optional[int] = None
+    default_multi_select: bool = False
+
+
+class AskUserQuestionIntegrator:
+    """
+    Integrates BatchQuestionsManager with Claude Code's AskUserQuestion.
+
+    This class provides a bridge between our question system and Claude Code's
+    built-in user interaction capabilities, ensuring consistent UX across
+    all MoAI skills.
+    """
+
+    def __init__(self, config: Optional[AskUserConfig] = None):
+        """Initialize the integrator with optional configuration."""
+        self.config = config or AskUserConfig()
+        self._setup_ask_user_function()
+
+    def _setup_ask_user_function(self):
+        """Setup the AskUserQuestion function reference."""
+        # This will be available when running in Claude Code environment
+        # For now, we'll create a mock implementation
+        try:
+            # In actual Claude Code environment, this would be available
+            from claude_code import ask_user_question as AskUserQuestion  # noqa: N812
+
+            self.AskUserQuestion = AskUserQuestion
+        except ImportError:
+            # Mock implementation for development/testing
+            self.AskUserQuestion = self._mock_ask_user_question
+            logger.warning("Using mock AskUserQuestion - not in Claude Code environment")
+
+    def _mock_ask_user_question(
+        self, questions: List[Dict[str, Any]], answers: Optional[Dict[str, str]] = None
+    ) -> Dict[str, str]:
+        """Mock implementation of AskUserQuestion for development."""
+        logger.info(f"Mock AskUserQuestion called with {len(questions)} questions")
+
+        # Return mock answers
+        mock_answers = {}
+        for q in questions:
+            if q.get("multiSelect", False):
+                # For multi-select, return first option
+                options = q.get("options", [])
+                if options:
+                    mock_answers[q["question"]] = [options[0]["label"]]
+            else:
+                # For single select, return first option
+                options = q.get("options", [])
+                if options:
+                    mock_answers[q["question"]] = options[0]["label"]
+                else:
+                    mock_answers[q["question"]] = "Default answer"
+
+        return mock_answers
+
+    def convert_question_to_ask_user_format(self, question: Question) -> Dict[str, Any]:
+        """
+        Convert a Question object to AskUserQuestion format.
+
+        Args:
+            question: Question to convert
+
+        Returns:
+            Dict: AskUserQuestion compatible format
+        """
+        ask_user_q = {
+            "question": question.text,
+            "multiSelect": question.type == QuestionType.MULTI_CHOICE,
+        }
+
+        # Add header if available
+        if question.metadata.get("header"):
+            ask_user_q["header"] = question.metadata["header"]
+
+        # Convert options
+        if question.options:
+            options = []
+            for opt in question.options:
+                option_dict = {
+                    "label": opt.label,
+                    "description": (opt.description if self.config.enable_descriptions else None),
+                }
+
+                # Only include non-None descriptions
+                if option_dict["description"] is None:
+                    del option_dict["description"]
+
+                options.append(option_dict)
+
+            ask_user_q["options"] = options
+
+        # Handle text input questions (convert to choice with text input)
+        elif question.type in [QuestionType.TEXT_INPUT, QuestionType.NUMBER_INPUT]:
+            ask_user_q["options"] = [
+                {
+                    "label": "Enter value...",
+                    "description": f"Type your {question.type.value}",
+                }
+            ]
+
+        # Handle boolean questions
+        elif question.type == QuestionType.BOOLEAN:
+            ask_user_q["options"] = [
+                {"label": "Yes", "description": "Confirm or accept"},
+                {"label": "No", "description": "Decline or reject"},
+            ]
+
+        # Add validation metadata
+        if question.validation and question.validation.required:
+            ask_user_q["required"] = True
+
+        return ask_user_q
+
+    def process_ask_user_response(self, question: Question, response_value: Union[str, List[str]]) -> Any:
+        """
+        Process AskUserQuestion response back to our expected format.
+
+        Args:
+            question: Original question
+            response_value: Response from AskUserQuestion
+
+        Returns:
+            Processed response value in our expected format
+        """
+        # Handle multi-select responses
+        if isinstance(response_value, list) and question.type == QuestionType.MULTI_CHOICE:
+            # Convert labels back to values
+            selected_values = []
+            for label in response_value:
+                for option in question.options:
+                    if option.label == label:
+                        selected_values.append(option.value)
+                        break
+            return selected_values
+
+        # Handle single-select responses
+        elif isinstance(response_value, str):
+            # For choice questions, convert label back to value
+            if question.options:
+                for option in question.options:
+                    if option.label == response_value:
+                        return option.value
+
+            # For text input questions, return as-is
+            elif question.type in [QuestionType.TEXT_INPUT, QuestionType.NUMBER_INPUT]:
+                # Convert number input to appropriate type
+                if question.type == QuestionType.NUMBER_INPUT:
+                    try:
+                        return int(response_value)
+                    except ValueError:
+                        try:
+                            return float(response_value)
+                        except ValueError:
+                            return response_value  # Keep as string if conversion fails
+                return response_value
+
+            # For boolean questions
+            elif question.type == QuestionType.BOOLEAN:
+                return response_value.lower() in ["yes", "y", "true", "1"]
+
+        return response_value
+
+    def ask_question(self, question: Question, context: Optional[Dict[str, Any]] = None) -> UserResponse:
+        """
+        Ask a single question using AskUserQuestion.
+
+        Args:
+            question: Question to ask
+            context: Current context for conditional questions
+
+        Returns:
+            UserResponse: The user's response
+        """
+        # Check if question should be asked based on conditional logic
+        if question.conditional_on and context:
+            should_ask = self._evaluate_condition(question.conditional_on, context)
+            if not should_ask:
+                # Return default response or skip
+                return UserResponse(
+                    question_id=question.id,
+                    value=question.default_value,
+                    metadata={"skipped": True, "reason": "conditional_not_met"},
+                )
+
+        # Convert to AskUserQuestion format
+        ask_user_q = self.convert_question_to_ask_user_format(question)
+
+        # Ask the question
+        try:
+            raw_response = self.AskUserQuestion([ask_user_q])
+            response_value = raw_response.get(ask_user_q["question"])
+
+            # Validate response
+            if question.validation:
+                validation_result = self._validate_response(response_value, question.validation)
+                if not validation_result.is_valid:
+                    raise ValueError(f"Invalid response: {validation_result.error}")
+
+            # Process response
+            processed_value = self.process_ask_user_response(question, response_value)
+
+            return UserResponse(
+                question_id=question.id,
+                value=processed_value,
+                metadata={"source": "ask_user_question", "raw_response": raw_response},
+            )
+
+        except Exception as e:
+            logger.error(f"Error asking question {question.id}: {e}")
+            # Return default value on error
+            return UserResponse(
+                question_id=question.id,
+                value=question.default_value,
+                metadata={"error": str(e), "fallback": True},
+            )
+
+    def ask_question_batch(
+        self, questions: List[Question], context: Optional[Dict[str, Any]] = None
+    ) -> Dict[str, UserResponse]:
+        """
+        Ask multiple questions in sequence using AskUserQuestion.
+
+        Args:
+            questions: List of questions to ask
+            context: Current context for conditional questions
+
+        Returns:
+            Dict[str, UserResponse]: All user responses
+        """
+        if context is None:
+            context = {}
+
+        responses = {}
+
+        for question in questions:
+            # Check if question already has response in context
+            if question.id in context:
+                responses[question.id] = UserResponse(
+                    question_id=question.id,
+                    value=context[question.id],
+                    metadata={"source": "context"},
+                )
+                continue
+
+            # Ask the question
+            response = self.ask_question(question, context)
+            responses[question.id] = response
+
+            # Update context for subsequent questions
+            if not response.metadata.get("skipped"):
+                context[question.id] = response.value
+
+        return responses
+
+    def _evaluate_condition(self, condition: Dict[str, Any], context: Dict[str, Any]) -> bool:
+        """Evaluate conditional logic for questions."""
+        if not self.config.enable_conditional:
+            return True
+
+        for key, expected in condition.items():
+            if key not in context:
+                return False
+
+            actual = context[key]
+            if isinstance(expected, list):
+                if actual not in expected:
+                    return False
+            elif actual != expected:
+                return False
+
+        return True
+
+    def _validate_response(self, value: Any, validation) -> "ValidationResult":
+        """Validate a response value."""
+        # This would integrate with the validation system
+        # For now, return a simple validation result
+        return ValidationResult(is_valid=True, error=None)
+
+
+@dataclass
+class ValidationResult:
+    """Result of response validation."""
+
+    is_valid: bool
+    error: Optional[str] = None
+    warnings: List[str] = field(default_factory=list)
+
+
+# Monkey patch BatchQuestionsManager to use AskUserQuestion integration
+
+
+def enhance_batch_questions_manager():
+    """Enhance BatchQuestionsManager with AskUserQuestion integration."""
+
+    def execute_batch_with_ask_user(self, batch, context=None):
+        """Execute batch using AskUserQuestion integration."""
+        if context is None:
+            context = {}
+
+        integrator = AskUserQuestionIntegrator()
+        questions = self.filter_questions(batch, context)
+        return integrator.ask_question_batch(questions, context)
+
+    # Patch the method
+    BatchQuestionsManager.execute_batch = execute_batch_with_ask_user
+
+    logger.info("Enhanced BatchQuestionsManager with AskUserQuestion integration")
+
+
+# Auto-enhance when module is imported
+enhance_batch_questions_manager()