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

moai_adk/templates/.claude/skills/moai-workflow-testing/scripts/with_server.py

@@ -0,0 +1,218 @@
+#!/usr/bin/env python3
+"""
+Start one or more servers, wait for them to be ready, run a command, then clean up.
+
+Usage:
+    # Single server
+    python scripts/with_server.py --server "npm run dev" --port 5173 -- python automation.py
+    python scripts/with_server.py --server "npm start" --port 3000 -- python test.py
+
+    # Multiple servers with working directories
+    python scripts/with_server.py \
+      --server "python server.py" --port 3000 --cwd backend \
+      --server "npm run dev" --port 5173 --cwd frontend \
+      -- python test.py
+
+Security Note:
+    This script uses shell=False to prevent command injection attacks (CWE-78).
+    Use --cwd to specify working directories instead of shell operators like 'cd'.
+"""
+
+import argparse
+import shlex
+import socket
+import subprocess
+import sys
+import time
+from pathlib import Path
+
+
+def is_server_ready(port, timeout=30):
+    """Wait for server to be ready by polling the port."""
+    start_time = time.time()
+    while time.time() - start_time < timeout:
+        try:
+            with socket.create_connection(("localhost", port), timeout=1):
+                return True
+        except (socket.error, ConnectionRefusedError):
+            time.sleep(0.5)
+    return False
+
+
+def parse_command_safely(cmd_string):
+    """
+    Parse a command string into a list for subprocess execution.
+
+    Uses shlex.split() for safe command parsing to prevent shell injection.
+    This handles quoted arguments properly but does NOT support shell operators
+    like &&, ||, |, ;, or redirections.
+
+    Args:
+        cmd_string: Command string to parse
+
+    Returns:
+        List of command arguments suitable for subprocess with shell=False
+
+    Raises:
+        ValueError: If command contains unsupported shell operators
+    """
+    # Check for shell operators that are not supported
+    shell_operators = ["&&", "||", "|", ";", ">", "<", ">>", "<<"]
+    for op in shell_operators:
+        if op in cmd_string:
+            raise ValueError(
+                f"Shell operator '{op}' is not supported for security reasons. "
+                f"Use --cwd to change working directory instead of 'cd &&'."
+            )
+
+    try:
+        return shlex.split(cmd_string)
+    except ValueError as e:
+        raise ValueError(f"Failed to parse command '{cmd_string}': {e}") from e
+
+
+def main():
+    parser = argparse.ArgumentParser(
+        description="Run command with one or more servers",
+        formatter_class=argparse.RawDescriptionHelpFormatter,
+        epilog="""
+Security:
+  This script uses shell=False to prevent command injection attacks (CWE-78).
+  Shell operators (&&, ||, |, ;) are not supported for security reasons.
+  Use --cwd to specify working directories instead of 'cd &&' patterns.
+
+Examples:
+  # Single server
+  python with_server.py --server "npm run dev" --port 3000 -- pytest
+
+  # Multiple servers with different working directories
+  python with_server.py \\
+    --server "python server.py" --port 3000 --cwd backend \\
+    --server "npm run dev" --port 5173 --cwd frontend \\
+    -- pytest tests/
+""",
+    )
+    parser.add_argument(
+        "--server",
+        action="append",
+        dest="servers",
+        required=True,
+        help="Server command (can be repeated)",
+    )
+    parser.add_argument(
+        "--port",
+        action="append",
+        dest="ports",
+        type=int,
+        required=True,
+        help="Port for each server (must match --server count)",
+    )
+    parser.add_argument(
+        "--cwd",
+        action="append",
+        dest="cwds",
+        default=None,
+        help="Working directory for each server (optional, defaults to current directory)",
+    )
+    parser.add_argument(
+        "--timeout",
+        type=int,
+        default=30,
+        help="Timeout in seconds per server (default: 30)",
+    )
+    parser.add_argument("command", nargs=argparse.REMAINDER, help="Command to run after server(s) ready")
+
+    args = parser.parse_args()
+
+    # Remove the '--' separator if present
+    if args.command and args.command[0] == "--":
+        args.command = args.command[1:]
+
+    if not args.command:
+        print("Error: No command specified to run")
+        sys.exit(1)
+
+    # Parse server configurations
+    if len(args.servers) != len(args.ports):
+        print("Error: Number of --server and --port arguments must match")
+        sys.exit(1)
+
+    # Handle working directories - default to None (current dir) for each server
+    cwds = args.cwds or []
+    while len(cwds) < len(args.servers):
+        cwds.append(None)
+
+    if len(cwds) > len(args.servers):
+        print("Error: Too many --cwd arguments (must not exceed number of --server arguments)")
+        sys.exit(1)
+
+    servers = []
+    for cmd, port, cwd in zip(args.servers, args.ports, cwds):
+        # Validate and resolve working directory
+        resolved_cwd = None
+        if cwd:
+            cwd_path = Path(cwd)
+            if not cwd_path.exists():
+                print(f"Error: Working directory '{cwd}' does not exist")
+                sys.exit(1)
+            if not cwd_path.is_dir():
+                print(f"Error: '{cwd}' is not a directory")
+                sys.exit(1)
+            resolved_cwd = str(cwd_path.resolve())
+
+        # Parse command safely
+        try:
+            cmd_list = parse_command_safely(cmd)
+        except ValueError as e:
+            print(f"Error: {e}")
+            sys.exit(1)
+
+        servers.append({"cmd": cmd, "cmd_list": cmd_list, "port": port, "cwd": resolved_cwd})
+
+    server_processes = []
+
+    try:
+        # Start all servers
+        for i, server in enumerate(servers):
+            cwd_info = f" (cwd: {server['cwd']})" if server["cwd"] else ""
+            print(f"Starting server {i + 1}/{len(servers)}: {server['cmd']}{cwd_info}")
+
+            # Use shell=False with parsed command list to prevent command injection (CWE-78)
+            process = subprocess.Popen(
+                server["cmd_list"],
+                stdout=subprocess.PIPE,
+                stderr=subprocess.PIPE,
+                cwd=server["cwd"],
+            )
+            server_processes.append(process)
+
+            # Wait for this server to be ready
+            print(f"Waiting for server on port {server['port']}...")
+            if not is_server_ready(server["port"], timeout=args.timeout):
+                raise RuntimeError(f"Server failed to start on port {server['port']} within {args.timeout}s")
+
+            print(f"Server ready on port {server['port']}")
+
+        print(f"\nAll {len(servers)} server(s) ready")
+
+        # Run the command
+        print(f"Running: {' '.join(args.command)}\n")
+        result = subprocess.run(args.command)
+        sys.exit(result.returncode)
+
+    finally:
+        # Clean up all servers
+        print(f"\nStopping {len(server_processes)} server(s)...")
+        for i, process in enumerate(server_processes):
+            try:
+                process.terminate()
+                process.wait(timeout=5)
+            except subprocess.TimeoutExpired:
+                process.kill()
+                process.wait()
+            print(f"Server {i + 1} stopped")
+        print("All servers stopped")
+
+
+if __name__ == "__main__":
+    main()

moai_adk/templates/.claude/skills/moai-workflow-testing/templates/alfred-integration.md

@@ -0,0 +1,376 @@
+# Alfred Agent Integration Template
+
+## 4-Step Workflow Integration
+
+### Step 1: Intent Understanding (User Requirement Analysis)
+```python
+# Pattern for Alfred agent to analyze user requests
+def analyze_user_intent(request: str) -> TestIntent:
+ """
+ Analyze user's test request to establish AI test strategy
+
+ Parameters:
+ - request: User request ("Test this web app", "Cross-browser testing needed")
+
+ Returns:
+ - TestIntent: Analyzed test intent and strategy
+ """
+ 
+ intent_patterns = {
+ 'comprehensive_testing': [' ', ' ', ' '],
+ 'regression_testing': [' ', ' ', ' '],
+ 'cross_browser': [' ', ' ', ''],
+ 'performance_testing': [' ', ' ', ''],
+ 'visual_regression': ['UI ', ' ', ' ']
+ }
+ 
+ # AI 
+ analyzed_intent = ai_intent_analyzer.analyze(request, intent_patterns)
+ 
+ return TestIntent(
+ primary_goal=analyzed_intent['goal'],
+ test_types=analyzed_intent['types'],
+ priority=analyzed_intent['priority'],
+ context=analyzed_intent['context']
+ )
+```
+
+### Step 2: Plan Creation (AI )
+```python
+# Context7 MCP AI 
+async def create_ai_test_plan(intent: TestIntent) -> TestPlan:
+ """
+ Context7 MCP AI 
+ 
+ :
+ - Playwright 
+ - AI 
+-
+ """
+ 
+ # Context7 Playwright 
+ latest_patterns = await context7_client.get_library_docs(
+ context7_library_id="/microsoft/playwright",
+ topic="enterprise testing automation patterns 2025",
+ tokens=5000
+ )
+ 
+ # AI 
+ ai_strategy = ai_test_generator.create_strategy(
+ intent=intent,
+ context7_patterns=latest_patterns,
+ best_practices=enterprise_patterns
+ )
+ 
+ return TestPlan(
+ strategy=ai_strategy,
+ context7_integration=True,
+ ai_enhancements=True,
+ enterprise_ready=True
+ )
+```
+
+### Step 3: Task Execution (AI )
+```python
+# AI 
+class AITestExecutor:
+ """AI """
+ 
+ def __init__(self):
+ self.context7_client = Context7Client()
+ self.ai_orchestrator = AITestOrchestrator()
+ 
+ async def execute_comprehensive_testing(self, test_plan: TestPlan) -> TestResults:
+ """
+ Context7 MCP AI 
+ 
+ :
+ 1. AI 
+ 2. Context7 
+3.
+ 4. AI 
+5.
+ """
+ 
+ # Step 1: AI-powered test generation
+ smart_tests = await self.ai_orchestrator.generate_smart_tests(test_plan)
+ 
+ # Step 2: Context7 pattern application
+ enhanced_tests = self.apply_context7_patterns(smart_tests)
+ 
+ # Step 3: Execute across browsers
+ cross_browser_results = await self.execute_cross_browser(enhanced_tests)
+ 
+ # Step 4: Visual regression with AI
+ visual_results = await self.ai_visual_regression_test(cross_browser_results)
+ 
+ # Step 5: Performance analysis
+ performance_results = await self.ai_performance_analysis(visual_results)
+ 
+ return TestResults(
+ functional=cross_browser_results,
+ visual=visual_results,
+ performance=performance_results,
+ ai_insights=self.generate_ai_insights(performance_results)
+ )
+```
+
+### Step 4: Report & Analysis (AI )
+```python
+# AI 
+async def generate_ai_test_report(results: TestResults) -> AIReport:
+ """
+ AI Context7 
+ 
+ :
+ - AI 
+ - Context7 
+-
+-
+ """
+ 
+ # AI 
+ ai_analysis = await ai_analyzer.analyze_test_results(results)
+ 
+ # Context7 
+ context7_validation = await validate_context7_application(results)
+ 
+ # 
+ recommendations = await ai_recommender.generate_recommendations(
+ test_results=results,
+ ai_analysis=ai_analysis,
+ context7_validation=context7_validation
+ )
+ 
+ return AIReport(
+ summary=create_executive_summary(results),
+ detailed_analysis=ai_analysis,
+ context7_insights=context7_validation,
+ action_items=recommendations,
+ next_steps=generate_next_steps(recommendations)
+ )
+```
+
+## Alfred Multi-Agent Coordination
+
+### 
+```python
+# Alfred 
+class AlfredAgentCoordinator:
+ """Alfred """
+ 
+ def __init__(self):
+ self.debug_agent = "moai-essentials-debug"
+ self.perf_agent = "moai-essentials-perf"
+ self.review_agent = "moai-essentials-review"
+ self.trust_agent = "moai-foundation-trust"
+ 
+ async def coordinate_with_debug_agent(self, test_failures: List[TestFailure]) -> DebugAnalysis:
+ """
+ 
+ 
+ :
+ - AI 
+ - Context7 
+-
+ """
+ 
+ debug_request = {
+ 'failures': test_failures,
+ 'context': 'webapp_testing',
+ 'ai_enhanced': True,
+ 'context7_patterns': True
+ }
+ 
+ # 
+ debug_result = await call_agent(self.debug_agent, debug_request)
+ 
+ return DebugAnalysis(
+ root_causes=debug_result['root_causes'],
+ suggested_fixes=debug_result['fixes'],
+ confidence_score=debug_result['confidence']
+ )
+ 
+ async def coordinate_with_performance_agent(self, performance_data: Dict) -> PerformanceOptimization:
+ """
+ 
+ 
+ :
+-
+-
+-
+ """
+ 
+ perf_request = {
+ 'performance_data': performance_data,
+ 'optimization_goals': ['speed', 'efficiency', 'ux'],
+ 'context7_best_practices': True
+ }
+ 
+ optimization_result = await call_agent(self.perf_agent, perf_request)
+ 
+ return PerformanceOptimization(
+ identified_bottlenecks=optimization_result['bottlenecks'],
+ optimization_strategies=optimization_result['strategies'],
+ expected_improvements=optimization_result['improvements']
+ )
+```
+
+## Perfect Gentleman 
+
+### UX 
+```python
+class KoreanUXOptimizer:
+ """Perfect Gentleman UX """
+ 
+ def __init__(self, conversation_language="ko"):
+ self.conversation_language = conversation_language
+ self.style_templates = self.load_style_templates()
+ 
+ def generate_korean_response(self, test_results: TestResults) -> KoreanResponse:
+ """
+ 
+ 
+ :
+-
+-
+-
+ """
+ 
+ if self.conversation_language == "ko":
+ response_template = self.style_templates['korean_formal']
+ 
+ return KoreanResponse(
+ greeting=response_template['greeting'],
+ summary=self.create_korean_summary(test_results),
+ detailed_findings=self.create_korean_findings(test_results),
+ recommendations=self.create_korean_recommendations(test_results),
+ closing=response_template['closing']
+ )
+ else:
+ return self.generate_english_response(test_results)
+ 
+ def create_korean_summary(self, results: TestResults) -> str:
+ """ """
+ 
+ pass_rate = results.calculate_pass_rate()
+ status = "" if pass_rate >= 90 else " " if pass_rate >= 70 else ""
+ 
+ summary = f"""
+ 
+
+ : {pass_rate:.1f}%
+ : {status}
+
+ :
+• {len(results.tests)} 
+• : {len(results.passed_tests)}
+• : {len(results.failed_tests)}
+• : {len(results.performance_issues)}
+
+AI : {self.get_ai_status_description(results.ai_insights)}
+ """
+ 
+ return summary.strip()
+```
+
+## TRUST 5 
+
+### 
+```python
+class TRUST5QualityAssurance:
+ """TRUST 5 """
+ 
+ async def validate_test_quality(self, test_results: TestResults) -> QualityReport:
+ """
+ TRUST 5 
+ 
+ TRUST 5:
+ - Test First: 
+ - Readable: 
+ - Unified: 
+ - Secured: 
+ - Trackable: 
+ """
+ 
+ quality_scores = {
+ 'test_first': self.validate_test_first_principle(test_results),
+ 'readable': self.validate_test_readability(test_results),
+ 'unified': self.validate_test_unification(test_results),
+ 'secured': self.validate_test_security(test_results),
+ 'trackable': self.validate_test_traceability(test_results)
+ }
+ 
+ overall_score = sum(quality_scores.values()) / len(quality_scores)
+ 
+ return QualityReport(
+ individual_scores=quality_scores,
+ overall_score=overall_score,
+ compliance_level=self.determine_compliance_level(overall_score),
+ improvement_recommendations=self.generate_improvement_recommendations(quality_scores)
+ )
+```
+
+## : Alfred 
+
+```python
+# Alfred 
+async def alfred_complete_testing_workflow(user_request: str):
+ """
+ Alfred 4-step AI 
+ 
+ 
+ """
+ 
+ # Step 1: Intent Understanding
+ intent = analyze_user_intent(user_request)
+ 
+ # Step 2: Plan Creation (with Context7 + AI)
+ test_plan = await create_ai_test_plan(intent)
+ 
+ # Step 3: Task Execution (AI-orchestrated)
+ test_executor = AITestExecutor()
+ results = await test_executor.execute_comprehensive_testing(test_plan)
+ 
+ # Step 4: Report & Analysis
+ report = await generate_ai_test_report(results)
+ 
+ # Multi-agent coordination
+ coordinator = AlfredAgentCoordinator()
+ 
+ if results.has_failures():
+ debug_analysis = await coordinator.coordinate_with_debug_agent(results.failures)
+ report.debug_insights = debug_analysis
+ 
+ if results.has_performance_issues():
+ perf_optimization = await coordinator.coordinate_with_performance_agent(results.performance_data)
+ report.performance_optimization = perf_optimization
+ 
+ # Quality assurance
+ qa_validator = TRUST5QualityAssurance()
+ quality_report = await qa_validator.validate_test_quality(results)
+ report.quality_assurance = quality_report
+ 
+ # Korean UX optimization
+ ux_optimizer = KoreanUXOptimizer()
+ korean_report = ux_optimizer.generate_korean_response(results)
+ 
+ return {
+ 'technical_report': report,
+ 'user_friendly_report': korean_report,
+ 'next_actions': generate_next_actions(report),
+ 'alfred_workflow_completed': True
+ }
+
+# 
+if __name__ == "__main__":
+ # 
+ user_input = " "
+ 
+ # Alfred 
+ result = await alfred_complete_testing_workflow(user_input)
+ 
+ # 
+ print(" Alfred AI ")
+ print(result['user_friendly_report'].summary)
+```