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

moai_adk/templates/.claude/skills/moai-workflow-testing/examples/ai-powered-testing.py

@@ -0,0 +1,294 @@
+"""
+AI-Powered Playwright Testing Examples
+Context7 MCP integration with intelligent test generation
+"""
+
+import asyncio
+import json
+from typing import Dict, List, Optional
+
+from playwright.sync_api import Page, expect, sync_playwright
+
+
+class AITestGenerator:
+    """AI-powered test generation with Context7 integration"""
+
+    def __init__(self, context7_client=None):
+        self.context7_client = context7_client
+        self.ai_patterns = {}
+
+    async def generate_smart_selectors(self, page: Page) -> Dict[str, str]:
+        """Generate intelligent CSS selectors using AI pattern recognition"""
+
+        # Get all interactive elements
+        buttons = page.locator("button").all()
+        page.locator("input").all()
+        page.locator("a[href]").all()
+
+        smart_selectors = {}
+
+        # AI-powered selector generation
+        for i, button in enumerate(buttons):
+            text = button.text_content()
+            if text:
+                # Generate robust selector
+                selector = f"button:has-text('{text.strip()}')"
+                smart_selectors[f"button_{i}"] = {
+                    "selector": selector,
+                    "text": text.strip(),
+                    "type": "button",
+                }
+
+        return smart_selectors
+
+    def generate_test_script(self, selectors: Dict, actions: List[str]) -> str:
+        """Generate automated test script using AI patterns"""
+
+        script_template = '''
+from playwright.sync_api import sync_playwright, expect
+
+def test_ai_generated_workflow():
+    """AI-generated test case with Context7 best practices"""
+
+    with sync_playwright() as p:
+        browser = p.chromium.launch(headless=False)
+        page = browser.new_page()
+
+        # Navigate and wait for content
+        page.goto('https://example.com')
+        page.wait_for_load_state('networkidle')
+
+        # AI-generated interactions
+{interactions}
+
+        # AI-powered assertions
+{assertions}
+
+        browser.close()
+
+if __name__ == "__main__":
+    test_ai_generated_workflow()
+        '''
+
+        interactions = []
+        assertions = []
+
+        for action in actions:
+            if "click" in action:
+                for name, info in selectors.items():
+                    if info["type"] == "button":
+                        interactions.append(f"        page.locator('{info['selector']}').click()")
+                        assertions.append(f"        expect(page.locator('{info['selector']}')).to_be_visible()")
+
+        return script_template.format(interactions="\n".join(interactions), assertions="\n".join(assertions))
+
+
+class Context7TestEnhancer:
+    """Context7 MCP integration for enhanced testing"""
+
+    async def get_latest_patterns(self, topic: str) -> Dict:
+        """Fetch latest Playwright patterns from Context7"""
+
+        # Simulate Context7 integration (would use actual Context7 client)
+        patterns = {
+            "visual_regression": {
+                "screenshot_comparison": True,
+                "ignore_regions": ["dynamic-content", "timestamps"],
+                "threshold": 0.1,
+                "wait_before_capture": 1000,
+            },
+            "cross_browser": {
+                "browsers": ["chromium", "firefox", "webkit"],
+                "viewports": [
+                    {"width": 1920, "height": 1080},
+                    {"width": 375, "height": 667},
+                ],
+                "devices": ["Desktop Chrome", "iPhone 12"],
+            },
+            "performance_testing": {
+                "metrics": ["FCP", "LCP", "TTI", "CLS"],
+                "thresholds": {"FCP": 1.8, "LCP": 2.5, "CLS": 0.1},
+            },
+        }
+
+        return patterns.get(topic, {})
+
+    def apply_context7_patterns(self, test_config: Dict) -> Dict:
+        """Apply Context7 best practices to test configuration"""
+
+        enhanced_config = test_config.copy()
+
+        # Apply Context7 patterns
+        enhanced_config["screenshot_options"] = {
+            "full_page": True,
+            "animations": "disabled",
+            "caret": "hide",
+        }
+
+        enhanced_config["wait_strategies"] = {
+            "networkidle": True,
+            "element_visible": True,
+            "timeout": 10000,
+        }
+
+        return enhanced_config
+
+
+class VisualRegressionTester:
+    """AI-powered visual regression testing"""
+
+    def __init__(self, baseline_dir: str = "./baseline"):
+        self.baseline_dir = baseline_dir
+        self.current_dir = "./current"
+        self.diff_dir = "./diff"
+
+    async def capture_screenshot(self, page: Page, name: str, selector: Optional[str] = None):
+        """Capture intelligent screenshot with Context7 patterns"""
+
+        # Wait for dynamic content
+        page.wait_for_load_state("networkidle")
+        await page.wait_for_timeout(1000)  # Allow animations
+
+        # Capture full page or specific element
+        if selector:
+            element = page.locator(selector)
+            screenshot_path = f"{self.current_dir}/{name}_element.png"
+            element.screenshot(path=screenshot_path)
+        else:
+            screenshot_path = f"{self.current_dir}/{name}_full.png"
+            page.screenshot(path=screenshot_path, full_page=True)
+
+        return screenshot_path
+
+    def compare_screenshots(self, baseline: str, current: str, diff: str) -> Dict:
+        """AI-powered screenshot comparison"""
+
+        # Simulate AI comparison (would use actual image comparison library)
+        comparison_result = {
+            "passed": True,
+            "diff_pixels": 0,
+            "diff_percentage": 0.0,
+            "regions_with_diff": [],
+            "recommendations": [],
+        }
+
+        return comparison_result
+
+
+class CrossBrowserOrchestrator:
+    """AI-coordinated cross-browser testing"""
+
+    def __init__(self):
+        self.browsers = ["chromium", "firefox", "webkit"]
+        self.results = {}
+
+    async def run_cross_browser_test(self, test_script: str) -> Dict:
+        """Execute test across multiple browsers with AI coordination"""
+
+        results = {}
+
+        for browser_name in self.browsers:
+            try:
+                with sync_playwright() as p:
+                    browser = getattr(p, browser_name).launch(headless=True)
+                    page = browser.new_page()
+
+                    # Execute test
+                    test_result = await self.execute_test_in_browser(page, test_script)
+
+                    results[browser_name] = {
+                        "status": "passed",
+                        "execution_time": test_result["time"],
+                        "assertions": test_result["assertions"],
+                        "issues": test_result.get("issues", []),
+                    }
+
+                    browser.close()
+
+            except Exception as e:
+                results[browser_name] = {"status": "failed", "error": str(e)}
+
+        return results
+
+    async def execute_test_in_browser(self, page: Page, test_script: str) -> Dict:
+        """Execute test script and capture results"""
+
+        import time
+
+        start_time = time.time()
+
+        # Simulate test execution
+        page.goto("https://example.com")
+        page.wait_for_load_state("networkidle")
+
+        # Perform assertions
+        assertions_passed = 0
+        assertions_total = 3
+
+        # Basic assertions
+        try:
+            expect(page.locator("h1")).to_be_visible()
+            assertions_passed += 1
+        except Exception:
+            pass
+
+        execution_time = time.time() - start_time
+
+        return {
+            "time": execution_time,
+            "assertions": f"{assertions_passed}/{assertions_total}",
+            "issues": [],
+        }
+
+
+# Example usage and integration
+async def main():
+    """Main AI-powered testing workflow"""
+
+    # Initialize components
+    ai_generator = AITestGenerator()
+    context7_enhancer = Context7TestEnhancer()
+    visual_tester = VisualRegressionTester()
+    cross_browser = CrossBrowserOrchestrator()
+
+    # Enhanced test configuration
+    test_config = {
+        "url": "https://example.com",
+        "browsers": ["chromium", "firefox"],
+        "viewports": [{"width": 1920, "height": 1080}],
+    }
+
+    # Apply Context7 patterns
+    enhanced_config = context7_enhancer.apply_context7_patterns(test_config)
+
+    print("🚀 AI-Powered Testing Workflow Started")
+    print(f"📋 Enhanced Configuration: {json.dumps(enhanced_config, indent=2)}")
+
+    # Generate and execute tests
+    with sync_playwright() as p:
+        browser = p.chromium.launch(headless=True)
+        page = browser.new_page()
+
+        # Navigate and analyze
+        page.goto("https://example.com")
+        page.wait_for_load_state("networkidle")
+
+        # AI-powered analysis
+        smart_selectors = await ai_generator.generate_smart_selectors(page)
+        print(f"🧠 AI Generated Selectors: {len(smart_selectors)} elements found")
+
+        # Visual regression
+        await visual_tester.capture_screenshot(page, "homepage")
+        print("📸 Visual regression screenshot captured")
+
+        browser.close()
+
+    # Cross-browser testing
+    cross_browser_results = await cross_browser.run_cross_browser_test("test_script")
+    print(f"🌐 Cross-browser results: {json.dumps(cross_browser_results, indent=2)}")
+
+    print("✅ AI-powered testing workflow completed")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

moai_adk/templates/.claude/skills/moai-workflow-testing/examples/console_logging.py

@@ -0,0 +1,35 @@
+from playwright.sync_api import sync_playwright
+
+# Example: Capturing console logs during browser automation
+
+url = "http://localhost:5173"  # Replace with your URL
+
+console_logs = []
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    page = browser.new_page(viewport={"width": 1920, "height": 1080})
+
+    # Set up console log capture
+    def handle_console_message(msg):
+        console_logs.append(f"[{msg.type}] {msg.text}")
+        print(f"Console: [{msg.type}] {msg.text}")
+
+    page.on("console", handle_console_message)
+
+    # Navigate to page
+    page.goto(url)
+    page.wait_for_load_state("networkidle")
+
+    # Interact with the page (triggers console logs)
+    page.click("text=Dashboard")
+    page.wait_for_timeout(1000)
+
+    browser.close()
+
+# Save console logs to file
+with open("/mnt/user-data/outputs/console.log", "w") as f:
+    f.write("\n".join(console_logs))
+
+print(f"\nCaptured {len(console_logs)} console messages")
+print("Logs saved to: /mnt/user-data/outputs/console.log")

moai_adk/templates/.claude/skills/moai-workflow-testing/examples/element_discovery.py

@@ -0,0 +1,40 @@
+from playwright.sync_api import sync_playwright
+
+# Example: Discovering buttons and other elements on a page
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    page = browser.new_page()
+
+    # Navigate to page and wait for it to fully load
+    page.goto("http://localhost:5173")
+    page.wait_for_load_state("networkidle")
+
+    # Discover all buttons on the page
+    buttons = page.locator("button").all()
+    print(f"Found {len(buttons)} buttons:")
+    for i, button in enumerate(buttons):
+        text = button.inner_text() if button.is_visible() else "[hidden]"
+        print(f"  [{i}] {text}")
+
+    # Discover links
+    links = page.locator("a[href]").all()
+    print(f"\nFound {len(links)} links:")
+    for link in links[:5]:  # Show first 5
+        text = link.inner_text().strip()
+        href = link.get_attribute("href")
+        print(f"  - {text} -> {href}")
+
+    # Discover input fields
+    inputs = page.locator("input, textarea, select").all()
+    print(f"\nFound {len(inputs)} input fields:")
+    for input_elem in inputs:
+        name = input_elem.get_attribute("name") or input_elem.get_attribute("id") or "[unnamed]"
+        input_type = input_elem.get_attribute("type") or "text"
+        print(f"  - {name} ({input_type})")
+
+    # Take screenshot for visual reference
+    page.screenshot(path="/tmp/page_discovery.png", full_page=True)
+    print("\nScreenshot saved to /tmp/page_discovery.png")
+
+    browser.close()

moai_adk/templates/.claude/skills/moai-workflow-testing/examples/static_html_automation.py

@@ -0,0 +1,34 @@
+import os
+
+from playwright.sync_api import sync_playwright
+
+# Example: Automating interaction with static HTML files using file:// URLs
+
+html_file_path = os.path.abspath("path/to/your/file.html")
+file_url = f"file://{html_file_path}"
+
+with sync_playwright() as p:
+    browser = p.chromium.launch(headless=True)
+    page = browser.new_page(viewport={"width": 1920, "height": 1080})
+
+    # Navigate to local HTML file
+    page.goto(file_url)
+
+    # Take screenshot
+    page.screenshot(path="/mnt/user-data/outputs/static_page.png", full_page=True)
+
+    # Interact with elements
+    page.click("text=Click Me")
+    page.fill("#name", "John Doe")
+    page.fill("#email", "john@example.com")
+
+    # Submit form
+    page.click('button[type="submit"]')
+    page.wait_for_timeout(500)
+
+    # Take final screenshot
+    page.screenshot(path="/mnt/user-data/outputs/after_submit.png", full_page=True)
+
+    browser.close()
+
+print("Static HTML automation completed!")

moai_adk/templates/.claude/skills/moai-workflow-testing/modules/README.md

@@ -0,0 +1,220 @@
+# Development Workflow Testing Modules
+
+> Purpose: Advanced implementation modules for comprehensive development workflow management
+> Structure: Modular architecture with focused, in-depth implementations
+> Compliance: Progressive disclosure with main SKILL.md under 500 lines
+
+## Module Overview
+
+This modules directory contains detailed implementation modules for the moai-workflow-testing skill. Each module provides comprehensive code examples, advanced features, and integration patterns that extend the core functionality described in the main SKILL.md file.
+
+## Available Modules
+
+### [AI-Powered Debugging](./ai-debugging.md)
+Complexity: Advanced | Time: 20+ minutes | Dependencies: Python 3.8+, Context7 MCP
+
+- Intelligent error classification with Context7 patterns
+- AI-driven solution generation with confidence scoring
+- Learning debugger that improves from previous fixes
+- Real-time error pattern recognition and prevention strategies
+
+Key Features:
+- Context7 integration for latest debugging patterns
+- Error frequency tracking and analysis
+- Automated solution generation with multiple approaches
+- Performance-aware debugging with minimal overhead
+
+### [Smart Refactoring](./smart-refactoring.md)
+Complexity: Advanced | Time: 25+ minutes | Dependencies: Python 3.8+, Rope, AST, Context7 MCP
+
+- Technical debt analysis with comprehensive code scanning
+- Safe automated refactoring with risk assessment
+- AI-driven refactoring suggestions with Context7 patterns
+- Dependency-aware refactoring with impact analysis
+
+Key Features:
+- Context7 refactoring patterns integration
+- Safe transformation planning with rollback strategies
+- Technical debt prioritization and quantification
+- Project-aware refactoring with convention detection
+
+### [Performance Optimization](./performance-optimization.md)
+Complexity: Advanced | Time: 30+ minutes | Dependencies: Python 3.8+, cProfile, memory_profiler, psutil
+
+- Real-time performance monitoring with configurable sampling
+- Bottleneck detection with AI-powered analysis
+- Automated optimization plan generation
+- Memory leak detection and optimization strategies
+
+Key Features:
+- Multi-dimensional performance analysis
+- Intelligent optimization suggestions with Context7 patterns
+- Continuous monitoring with alerting capabilities
+- Performance regression detection and prevention
+
+### [TDD with Context7](./tdd-context7.md)
+Complexity: Advanced | Time: 25+ minutes | Dependencies: Python 3.8+, pytest, Context7 MCP
+
+- RED-GREEN-REFACTOR cycle automation with AI assistance
+- Context7-enhanced test generation and pattern matching
+- Intelligent test case generation from specifications
+- Automated test suite optimization and maintenance
+
+Key Features:
+- Context7 testing patterns and best practices
+- AI-powered test case generation with coverage optimization
+- Comprehensive test specification management
+- Automated test execution with quality validation
+
+### [Automated Code Review](./automated-code-review.md)
+Complexity: Advanced | Time: 35+ minutes | Dependencies: Python 3.8+, pylint, flake8, bandit, mypy
+
+- TRUST 5 framework validation with AI analysis
+- Multi-tool static analysis integration and aggregation
+- Context7 security patterns and vulnerability detection
+- Automated fix suggestions with diff generation
+
+Key Features:
+- Comprehensive TRUST 5 category scoring
+- Context7 security and quality pattern integration
+- Automated issue detection with prioritization
+- Integration with CI/CD pipelines and quality gates
+
+## Module Integration
+
+### Using Individual Modules
+
+Each module can be used independently or as part of the unified workflow system:
+
+```python
+# Import specific module components
+from moai_workflow_testing.modules.ai_debugging import AIDebugger
+from moai_workflow_testing.modules.performance_optimization import PerformanceProfiler
+
+# Use modules independently
+debugger = AIDebugger(context7_client=context7)
+profiler = PerformanceProfiler(context7_client=context7)
+```
+
+### Unified Workflow Integration
+
+All modules are designed to work together seamlessly:
+
+```python
+from moai_workflow_testing import DevelopmentWorkflow
+
+# Complete workflow with all modules
+workflow = DevelopmentWorkflow(
+ project_path="/project/src",
+ context7_client=context7,
+ enable_all_modules=True
+)
+
+results = await workflow.execute_complete_workflow()
+```
+
+## Module Dependencies
+
+### Core Dependencies
+- Python 3.8+: Base runtime environment
+- Context7 MCP: For pattern integration and AI assistance
+- asyncio: Asynchronous execution support
+
+### Module-Specific Dependencies
+- Performance Optimization: cProfile, memory_profiler, psutil, line_profiler
+- Smart Refactoring: Rope, AST, Context7 patterns
+- Automated Code Review: pylint, flake8, bandit, mypy
+- TDD: pytest, unittest, coverage, Context7 testing patterns
+
+## Best Practices
+
+### Module Selection
+1. Start with main SKILL.md: Use the overview to understand capabilities
+2. Progress to modules: Dive into specific modules as needed
+3. Combine selectively: Use only the modules relevant to your workflow
+
+### Integration Guidelines
+1. Context7 Integration: Enable Context7 for enhanced AI capabilities
+2. Performance Considerations: Monitor overhead of analysis tools
+3. Quality Gates: Configure appropriate thresholds for your project
+
+### Maintenance
+1. Regular Updates: Keep Context7 patterns current
+2. Tool Versions: Maintain compatible static analysis tool versions
+3. Pattern Evolution: Update patterns as best practices evolve
+
+## Module Development
+
+### Adding New Modules
+
+To add a new module to this skill:
+
+1. Create Module File: Use the established template pattern
+2. Follow Structure: Include core implementation, advanced features, and best practices
+3. Update References: Add module reference to main SKILL.md
+4. Test Integration: Ensure compatibility with existing modules
+
+### Module Template
+
+```markdown
+# Module Title
+
+> Module: Brief module description
+> Complexity: Basic|Intermediate|Advanced
+> Time: X+ minutes
+> Dependencies: List of required libraries
+
+## Core Implementation
+
+[Complete implementation with comprehensive examples]
+
+## Advanced Features
+
+[Extended functionality and integration patterns]
+
+## Best Practices
+
+[Guidelines for production use]
+
+---
+
+Module: `modules/module-name.md`
+Related: [Other Module](./other-module.md) | [Related Module](./related-module.md)
+```
+
+## Quality Assurance
+
+### Module Standards
+- Comprehensive documentation with examples
+- Error handling and edge case coverage
+- Performance considerations and optimizations
+- Context7 integration where appropriate
+- Cross-module compatibility testing
+
+### Validation Checklist
+- [ ] Module compiles and runs without errors
+- [ ] Examples are functional and tested
+- [ ] Documentation is complete and accurate
+- [ ] Integration with other modules works
+- [ ] Performance meets acceptable standards
+
+## Support and Contributing
+
+### Module Support
+- Documentation: Each module includes comprehensive usage examples
+- Integration: See main SKILL.md for integration patterns
+- Dependencies: Check individual modules for specific requirements
+
+### Contributing
+When contributing to modules:
+
+1. Follow Templates: Use established module structure
+2. Test Thoroughly: Ensure compatibility with existing modules
+3. Document Completely: Include comprehensive examples and use cases
+4. Update References: Keep main SKILL.md and README current
+
+---
+
+Last Updated: 2025-11-30
+Module Count: 5 comprehensive modules
+Maintained by: MoAI-ADK Development Workflow Team