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

moai_adk/templates/.claude/skills/moai-workflow-project/templates/question-templates/project-batch-questions.json

@@ -0,0 +1,97 @@
+{
+  "id": "project-batch-questions",
+  "title": "Project Batch Questions Configuration",
+  "description": "Configure project-specific question batches and templates",
+  "questions": [
+    {
+      "id": "batch_questions.enable",
+      "text": "Enable batch question processing for this project?",
+      "type": "boolean",
+      "required": true,
+      "default_value": true,
+      "description": "Allow collecting multiple questions in batches for better workflow"
+    },
+    {
+      "id": "batch_questions.template_directory",
+      "text": "Where should question templates be stored?",
+      "type": "single_choice",
+      "required": true,
+      "default_value": ".moai/templates/questions",
+      "options": [
+        {
+          "label": "Default (.moai/templates/questions)",
+          "value": ".moai/templates/questions",
+          "description": "Standard MoAI template location"
+        },
+        {
+          "label": "Project root (.questions)",
+          "value": ".questions",
+          "description": "Project root directory"
+        },
+        {
+          "label": "Custom location",
+          "value": "custom",
+          "description": "Specify custom directory path"
+        }
+      ]
+    },
+    {
+      "id": "batch_questions.custom_path",
+      "text": "Enter custom template directory path:",
+      "type": "text_input",
+      "required": false,
+      "conditional_on": {
+        "batch_questions.template_directory": "custom"
+      },
+      "validation": {
+        "rules": ["min_length"],
+        "parameters": {"min_length": 1}
+      }
+    },
+    {
+      "id": "batch_questions.auto_save",
+      "text": "Automatically save question responses?",
+      "type": "boolean",
+      "required": true,
+      "default_value": true,
+      "description": "Save responses to .moai/responses/ for future reference"
+    },
+    {
+      "id": "batch_questions.validation_level",
+      "text": "What level of response validation should be applied?",
+      "type": "single_choice",
+      "required": true,
+      "default_value": "standard",
+      "options": [
+        {
+          "label": "Basic (required fields only)",
+          "value": "basic",
+          "description": "Only validate required fields are present"
+        },
+        {
+          "label": "Standard (type and format validation)",
+          "value": "standard",
+          "description": "Validate field types and basic formats"
+        },
+        {
+          "label": "Strict (custom validation rules)",
+          "value": "strict",
+          "description": "Apply comprehensive validation including custom rules"
+        }
+      ]
+    },
+    {
+      "id": "batch_questions.conditional_logic",
+      "text": "Enable conditional question logic?",
+      "type": "boolean",
+      "required": true,
+      "default_value": true,
+      "description": "Show/hide questions based on previous answers"
+    }
+  ],
+  "metadata": {
+    "skill": "moai-project-batch-questions",
+    "category": "project_configuration",
+    "version": "1.0.0"
+  }
+}

moai_adk/templates/.claude/skills/moai-workflow-project/templates/question-templates/spec-workflow-setup.json

@@ -0,0 +1,150 @@
+{
+  "id": "spec-workflow-setup",
+  "title": "SPEC Workflow Configuration",
+  "description": "Configure specification-driven development workflow preferences",
+  "questions": [
+    {
+      "id": "spec_workflow.auto_generate",
+      "text": "Enable automatic SPEC generation for new features?",
+      "type": "boolean",
+      "required": true,
+      "default_value": true,
+      "description": "Automatically create SPEC documents when starting new features"
+    },
+    {
+      "id": "spec_workflow.template_style",
+      "text": "Choose SPEC template style:",
+      "type": "single_choice",
+      "required": true,
+      "default_value": "ears",
+      "options": [
+        {
+          "label": "EARS Format (Easy Approach to Requirements Syntax)",
+          "value": "ears",
+          "description": "Structured requirements format with clear syntax"
+        },
+        {
+          "label": "User Story Format",
+          "value": "user_story",
+          "description": "Agile user story format with acceptance criteria"
+        },
+        {
+          "label": "Technical Specification",
+          "value": "technical",
+          "description": "Detailed technical specification format"
+        },
+        {
+          "label": "Minimal",
+          "value": "minimal",
+          "description": "Lightweight specification format"
+        }
+      ]
+    },
+    {
+      "id": "spec_workflow.review_process",
+      "text": "Enable SPEC review process?",
+      "type": "boolean",
+      "required": true,
+      "default_value": true,
+      "description": "Require review and approval before implementation"
+    },
+    {
+      "id": "spec_workflow.reviewers",
+      "text": "Who should review SPECs?",
+      "type": "multi_choice",
+      "required": true,
+      "default_value": ["tech_lead"],
+      "conditional_on": {
+        "spec_workflow.review_process": true
+      },
+      "options": [
+        {
+          "label": "Technical Lead",
+          "value": "tech_lead",
+          "description": "Senior technical team member"
+        },
+        {
+          "label": "Product Manager",
+          "value": "product_manager",
+          "description": "Product owner or manager"
+        },
+        {
+          "label": "Security Expert",
+          "value": "security_expert",
+          "description": "Security team member or expert"
+        },
+        {
+          "label": "UX Designer",
+          "value": "ux_designer",
+          "description": "User experience designer"
+        },
+        {
+          "label": "Peer Developer",
+          "value": "peer_developer",
+          "description": "Fellow developer team member"
+        },
+        {
+          "label": "Auto-approve",
+          "value": "auto_approve",
+          "description": "No manual review required"
+        }
+      ]
+    },
+    {
+      "id": "spec_workflow.tracking",
+      "text": "Enable SPEC progress tracking?",
+      "type": "boolean",
+      "required": true,
+      "default_value": true,
+      "description": "Track SPEC status through implementation lifecycle"
+    },
+    {
+      "id": "spec_workflow.integration",
+      "text": "Integrate SPECs with development workflow:",
+      "type": "multi_choice",
+      "required": true,
+      "default_value": ["git_branches", "issue_tracking"],
+      "options": [
+        {
+          "label": "Git Branches",
+          "value": "git_branches",
+          "description": "Create branches based on SPEC IDs"
+        },
+        {
+          "label": "Issue Tracking",
+          "value": "issue_tracking",
+          "description": "Link SPECs to issue tracker tickets"
+        },
+        {
+          "label": "CI/CD Pipeline",
+          "value": "cicd",
+          "description": "Include SPEC validation in pipeline"
+        },
+        {
+          "label": "Documentation",
+          "value": "documentation",
+          "description": "Auto-generate documentation from SPECs"
+        }
+      ]
+    },
+    {
+      "id": "spec_workflow.approval_threshold",
+      "text": "Number of approvals required for SPEC:",
+      "type": "number_input",
+      "required": true,
+      "default_value": 1,
+      "conditional_on": {
+        "spec_workflow.review_process": true
+      },
+      "validation": {
+        "rules": ["min_value", "max_value"],
+        "parameters": {"min_value": 1, "max_value": 5}
+      }
+    }
+  ],
+  "metadata": {
+    "skill": "moai-spec-intelligent-workflow",
+    "category": "workflow_configuration",
+    "version": "1.0.0"
+  }
+}

moai_adk/templates/.claude/skills/moai-workflow-project/test_integration_simple.py

@@ -0,0 +1,436 @@
+#!/usr/bin/env python3
+"""
+Simple Integration Test for moai-menu-project
+
+Tests the core functionality without complex imports.
+"""
+
+import sys
+import tempfile
+from pathlib import Path
+
+# Add modules to path
+sys.path.insert(0, "modules")
+
+# Import individual modules
+import documentation_manager
+import language_initializer
+import template_optimizer
+
+
+def test_individual_modules():
+    """Test each module individually."""
+    print("🧪 Testing Individual Modules")
+    print("=" * 40)
+
+    # Create temporary directory
+    test_dir = Path(tempfile.mkdtemp())
+    print(f"📁 Test directory: {test_dir}")
+
+    # Test configuration
+    config = {
+        "project": {"name": "Test Project", "type": "web_application"},
+        "language": {"conversation_language": "en", "documentation_language": "en"},
+    }
+
+    results = {}
+
+    # Test DocumentationManager
+    print("\\n📚 Testing DocumentationManager...")
+    try:
+        doc_manager = documentation_manager.DocumentationManager(str(test_dir), config)
+
+        # Test initialization
+        init_result = doc_manager.initialize_documentation_structure()
+        results["documentation_manager"] = {
+            "success": init_result["success"],
+            "created_files": len(init_result.get("created_files", [])),
+        }
+
+        # Test SPEC documentation generation
+        spec_data = {
+            "id": "TEST-SPEC-001",
+            "title": "Test Feature",
+            "description": "Test feature implementation",
+            "requirements": ["Requirement 1", "Requirement 2"],
+            "api_endpoints": [{"path": "/api/test", "method": "POST", "description": "Test endpoint"}],
+        }
+
+        docs_result = doc_manager.generate_documentation_from_spec(spec_data)
+        results["documentation_manager"]["spec_generation"] = docs_result["success"]
+
+        print(f"✅ DocumentationManager: {init_result['success']}")
+        print(f"  📄 Files created: {len(init_result.get('created_files', []))}")
+        print(f"  📝 SPEC generation: {docs_result['success']}")
+
+    except Exception as e:
+        print(f"❌ DocumentationManager error: {e}")
+        results["documentation_manager"] = {"success": False, "error": str(e)}
+
+    # Test LanguageInitializer
+    print("\\n🌐 Testing LanguageInitializer...")
+    try:
+        lang_init = language_initializer.LanguageInitializer(str(test_dir), config)
+
+        # Test language detection
+        detected_lang = lang_init.detect_project_language()
+
+        # Test language configuration
+        lang_result = lang_init.initialize_language_configuration(
+            language="ko", user_name="테스트 사용자", domains=["backend", "frontend"]
+        )
+
+        # Test multilingual structure
+        multilingual_result = lang_init.create_multilingual_documentation_structure("ko")
+
+        results["language_initializer"] = {
+            "success": lang_result["success"],
+            "detected_language": detected_lang,
+            "multilingual_created": multilingual_result["success"],
+        }
+
+        print(f"✅ LanguageInitializer: {lang_result['success']}")
+        print(f"  💬 Detected language: {detected_lang}")
+        print(f"  🌍 Multilingual structure: {multilingual_result['success']}")
+
+    except Exception as e:
+        print(f"❌ LanguageInitializer error: {e}")
+        results["language_initializer"] = {"success": False, "error": str(e)}
+
+    # Test TemplateOptimizer
+    print("\\n⚡ Testing TemplateOptimizer...")
+    try:
+        # Create test templates
+        templates_dir = test_dir / "templates"
+        templates_dir.mkdir(exist_ok=True)
+
+        test_template = """
+# Test Template
+
+This template contains redundant content.
+
+## Section 1
+
+Content here...
+
+## Section 1  # Duplicate
+
+Duplicate content here...
+
+Extra whitespace:
+
+Complex logic:
+{% if condition %}
+    {% if nested_condition %}
+        Content
+    {% endif %}
+{% endif %}
+        """
+
+        (templates_dir / "test_template.md").write_text(test_template, encoding="utf-8")
+
+        template_opt = template_optimizer.TemplateOptimizer(str(test_dir), config)
+
+        # Test template analysis
+        analysis = template_opt.analyze_project_templates()
+
+        # Test optimization
+        optimization_result = template_opt.create_optimized_templates({"backup_first": True})
+
+        # Test benchmarking
+        benchmark_result = template_opt.benchmark_template_performance()
+
+        results["template_optimizer"] = {
+            "success": analysis["success"],
+            "files_analyzed": len(analysis.get("analyzed_files", [])),
+            "optimization_applied": optimization_result.get("success", False),
+            "benchmark_completed": benchmark_result.get("success", False),
+        }
+
+        print(f"✅ TemplateOptimizer: {analysis['success']}")
+        print(f"  📁 Files analyzed: {len(analysis.get('analyzed_files', []))}")
+        print(f"  ⚡ Optimization applied: {optimization_result.get('success', False)}")
+        print(f"  🏃 Benchmark completed: {benchmark_result.get('success', False)}")
+
+    except Exception as e:
+        print(f"❌ TemplateOptimizer error: {e}")
+        results["template_optimizer"] = {"success": False, "error": str(e)}
+
+    # Cleanup
+    import shutil
+
+    shutil.rmtree(test_dir, ignore_errors=True)
+
+    return results
+
+
+def test_module_integration():
+    """Test integration between modules."""
+    print("\\n🔗 Testing Module Integration")
+    print("=" * 40)
+
+    # Create temporary directory
+    test_dir = Path(tempfile.mkdtemp())
+
+    try:
+        # Initialize all three modules with same config
+        config = {
+            "project": {"name": "Integration Test Project", "type": "web_application"},
+            "language": {"conversation_language": "ko", "documentation_language": "ko"},
+        }
+
+        # Initialize modules
+        doc_manager = documentation_manager.DocumentationManager(str(test_dir), config)
+        lang_init = language_initializer.LanguageInitializer(str(test_dir), config)
+        template_opt = template_optimizer.TemplateOptimizer(str(test_dir), config)
+
+        print("✅ All modules initialized successfully")
+
+        # Test 1: Language + Documentation integration
+        print("\\n🌐📚 Testing Language + Documentation integration...")
+
+        # Set up language configuration
+        lang_result = lang_init.initialize_language_configuration(
+            language="ko", user_name="통합 테스트", domains=["backend"]
+        )
+
+        # Create documentation structure
+        doc_result = doc_manager.initialize_documentation_structure()
+
+        # Test multilingual documentation
+        multilingual_result = lang_init.create_multilingual_documentation_structure("ko")
+
+        integration_success = all(
+            [
+                lang_result["success"],
+                doc_result["success"],
+                multilingual_result["success"],
+            ]
+        )
+
+        print(f"✅ Language + Documentation integration: {integration_success}")
+
+        # Test 2: Template + Documentation integration
+        print("\\n⚡📚 Testing Template + Documentation integration...")
+
+        # Create test templates
+        templates_dir = test_dir / "templates"
+        templates_dir.mkdir(exist_ok=True)
+
+        (templates_dir / "docs_template.md").write_text(
+            "# Documentation Template\\n\\nContent here...", encoding="utf-8"
+        )
+
+        # Analyze templates
+        analysis = template_opt.analyze_project_templates()
+
+        # Generate documentation using templates
+        spec_data = {
+            "id": "INTEGRATION-SPEC",
+            "title": "통합 테스트 기능",
+            "description": "모듈 통합 테스트",
+            "requirements": ["요구사항 1", "요구사항 2"],
+        }
+
+        docs_from_spec = doc_manager.generate_documentation_from_spec(spec_data)
+
+        template_doc_success = analysis["success"] and docs_from_spec["success"]
+
+        print(f"✅ Template + Documentation integration: {template_doc_success}")
+
+        # Test 3: All modules together
+        print("\\n🔧🌐📚 Testing all modules together...")
+
+        # Complete workflow
+        workflow_success = True
+
+        # 1. Language setup
+        lang_result = lang_init.initialize_language_configuration(language="ja")
+        workflow_success &= lang_result["success"]
+
+        # 2. Documentation initialization
+        doc_result = doc_manager.initialize_documentation_structure()
+        workflow_success &= doc_result["success"]
+
+        # 3. Template analysis
+        analysis = template_opt.analyze_project_templates()
+        workflow_success &= analysis["success"]
+
+        print(f"✅ Complete workflow: {workflow_success}")
+
+        return {
+            "language_docs_integration": integration_success,
+            "template_docs_integration": template_doc_success,
+            "complete_workflow": workflow_success,
+        }
+
+    except Exception as e:
+        print(f"❌ Integration test error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return {"success": False, "error": str(e)}
+
+    finally:
+        # Cleanup
+        import shutil
+
+        shutil.rmtree(test_dir, ignore_errors=True)
+
+
+def test_performance():
+    """Test performance characteristics."""
+    print("\\n📈 Performance Testing")
+    print("=" * 30)
+
+    import time
+
+    # Create temporary directory
+    test_dir = Path(tempfile.mkdtemp())
+
+    try:
+        config = {
+            "project": {"name": "Performance Test", "type": "web_application"},
+            "language": {"conversation_language": "en"},
+        }
+
+        performance_results = {}
+
+        # Test module initialization time
+        start_time = time.time()
+
+        doc_manager = documentation_manager.DocumentationManager(str(test_dir), config)
+        lang_init = language_initializer.LanguageInitializer(str(test_dir), config)
+        template_opt = template_optimizer.TemplateOptimizer(str(test_dir), config)
+
+        init_time = time.time() - start_time
+        performance_results["module_initialization"] = init_time
+
+        print(f"⏱️  Module initialization: {init_time:.3f}s")
+
+        # Test documentation generation time
+        start_time = time.time()
+
+        doc_manager.initialize_documentation_structure()
+
+        doc_time = time.time() - start_time
+        performance_results["documentation_generation"] = doc_time
+
+        print(f"⏱️  Documentation generation: {doc_time:.3f}s")
+
+        # Test language detection time
+        start_time = time.time()
+
+        # Create some test files
+        (test_dir / "test.py").write_text(
+            "# Korean comments\\ndef calculate():\\n    # 계산 함수\\n    return 100",
+            encoding="utf-8",
+        )
+
+        lang_init.detect_project_language()
+
+        lang_time = time.time() - start_time
+        performance_results["language_detection"] = lang_time
+
+        print(f"⏱️  Language detection: {lang_time:.3f}s")
+
+        # Test template analysis time
+        templates_dir = test_dir / "templates"
+        templates_dir.mkdir(exist_ok=True)
+
+        # Create multiple test templates
+        for i in range(5):
+            (templates_dir / f"template_{i}.md").write_text(
+                f"# Template {i}\\n\\nContent for template {i}.", encoding="utf-8"
+            )
+
+        start_time = time.time()
+
+        template_opt.analyze_project_templates()
+
+        template_time = time.time() - start_time
+        performance_results["template_analysis"] = template_time
+
+        print(f"⏱️  Template analysis (5 files): {template_time:.3f}s")
+
+        # Performance benchmarks
+        print("\\n📊 Performance Benchmarks:")
+        print(f"  Module initialization (<1s): {'✅' if init_time < 1.0 else '❌'}")
+        print(f"  Documentation generation (<3s): {'✅' if doc_time < 3.0 else '❌'}")
+        print(f"  Language detection (<0.5s): {'✅' if lang_time < 0.5 else '❌'}")
+        print(f"  Template analysis (<2s): {'✅' if template_time < 2.0 else '❌'}")
+
+        total_time = sum(performance_results.values())
+        print(f"\\n🕐 Total time: {total_time:.3f}s")
+
+        return performance_results
+
+    finally:
+        # Cleanup
+        import shutil
+
+        shutil.rmtree(test_dir, ignore_errors=True)
+
+
+def main():
+    """Run all integration tests."""
+    print("🧪 MoAI Menu Project - Integration Test Suite")
+    print("=" * 50)
+    print("Testing core functionality and module integration")
+    print("=" * 50)
+
+    try:
+        # Run individual module tests
+        module_results = test_individual_modules()
+
+        # Run integration tests
+        integration_results = test_module_integration()
+
+        # Run performance tests
+        performance_results = test_performance()
+
+        # Summary
+        print("\\n🎉 Test Summary")
+        print("=" * 20)
+
+        # Module success rates
+        total_modules = len(module_results)
+        successful_modules = sum(1 for result in module_results.values() if result.get("success", False))
+
+        print(f"📦 Modules: {successful_modules}/{total_modules} successful")
+
+        # Integration success rates
+        total_integrations = len(integration_results)
+        successful_integrations = sum(1 for result in integration_results.values() if result is True)
+
+        print(f"🔗 Integrations: {successful_integrations}/{total_integrations} successful")
+
+        # Performance summary
+        avg_time = sum(performance_results.values()) / len(performance_results)
+        print(f"📈 Average operation time: {avg_time:.3f}s")
+
+        # Overall assessment
+        overall_success = successful_modules == total_modules and successful_integrations == total_integrations
+
+        print(f"\\n🎯 Overall Result: {'✅ SUCCESS' if overall_success else '❌ ISSUES DETECTED'}")
+
+        if overall_success:
+            print("\\n🚀 MoAI Menu Project system is fully functional!")
+            print("✅ All modules working correctly")
+            print("✅ Module integration successful")
+            print("✅ Performance within acceptable limits")
+        else:
+            print("\\n⚠️  Some issues detected - review test results")
+
+        return 0 if overall_success else 1
+
+    except Exception as e:
+        print(f"\\n❌ Test suite failed with error: {e}")
+        import traceback
+
+        traceback.print_exc()
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())