claude-mpm 4.20.3__py3-none-any.whl → 5.1.8__py3-none-any.whl

claude_mpm/skills/bundled/main/mcp-builder/scripts/evaluation.py

@@ -64,10 +64,12 @@ def parse_evaluation_file(file_path: Path) -> list[dict[str, Any]]:
             answer_elem = qa_pair.find("answer")
 
             if question_elem is not None and answer_elem is not None:
-                evaluations.append({
-                    "question": (question_elem.text or "").strip(),
-                    "answer": (answer_elem.text or "").strip(),
-                })
+                evaluations.append(
+                    {
+                        "question": (question_elem.text or "").strip(),
+                        "answer": (answer_elem.text or "").strip(),
+                    }
+                )
 
         return evaluations
     except Exception as e:
@@ -113,7 +115,11 @@ async def agent_loop(
         tool_start_ts = time.time()
         try:
             tool_result = await connection.call_tool(tool_name, tool_input)
-            tool_response = json.dumps(tool_result) if isinstance(tool_result, (dict, list)) else str(tool_result)
+            tool_response = (
+                json.dumps(tool_result)
+                if isinstance(tool_result, (dict, list))
+                else str(tool_result)
+            )
         except Exception as e:
             tool_response = f"Error executing tool {tool_name}: {e!s}\n"
             tool_response += traceback.format_exc()
@@ -124,14 +130,18 @@ async def agent_loop(
         tool_metrics[tool_name]["count"] += 1
         tool_metrics[tool_name]["durations"].append(tool_duration)
 
-        messages.append({
-            "role": "user",
-            "content": [{
-                "type": "tool_result",
-                "tool_use_id": tool_use.id,
-                "content": tool_response,
-            }]
-        })
+        messages.append(
+            {
+                "role": "user",
+                "content": [
+                    {
+                        "type": "tool_result",
+                        "tool_use_id": tool_use.id,
+                        "content": tool_response,
+                    }
+                ],
+            }
+        )
 
         response = await asyncio.to_thread(
             client.messages.create,
@@ -162,7 +172,9 @@ async def evaluate_single_task(
     start_time = time.time()
 
     print(f"Task {task_index + 1}: Running task with question: {qa_pair['question']}")
-    response, tool_metrics = await agent_loop(client, model, qa_pair["question"], tools, connection)
+    response, tool_metrics = await agent_loop(
+        client, model, qa_pair["question"], tools, connection
+    )
 
     response_value = extract_xml_content(response, "response")
     summary = extract_xml_content(response, "summary")
@@ -177,7 +189,9 @@ async def evaluate_single_task(
         "score": int(response_value == qa_pair["answer"]) if response_value else 0,
         "total_duration": duration_seconds,
         "tool_calls": tool_metrics,
-        "num_tool_calls": sum(len(metrics["durations"]) for metrics in tool_metrics.values()),
+        "num_tool_calls": sum(
+            len(metrics["durations"]) for metrics in tool_metrics.values()
+        ),
         "summary": summary,
         "feedback": feedback,
     }
@@ -235,13 +249,19 @@ async def run_evaluation(
     results = []
     for i, qa_pair in enumerate(qa_pairs):
         print(f"Processing task {i + 1}/{len(qa_pairs)}")
-        result = await evaluate_single_task(client, model, qa_pair, tools, connection, i)
+        result = await evaluate_single_task(
+            client, model, qa_pair, tools, connection, i
+        )
         results.append(result)
 
     correct = sum(r["score"] for r in results)
     accuracy = (correct / len(results)) * 100 if results else 0
-    average_duration_s = sum(r["total_duration"] for r in results) / len(results) if results else 0
-    average_tool_calls = sum(r["num_tool_calls"] for r in results) / len(results) if results else 0
+    average_duration_s = (
+        sum(r["total_duration"] for r in results) / len(results) if results else 0
+    )
+    average_tool_calls = (
+        sum(r["num_tool_calls"] for r in results) / len(results) if results else 0
+    )
     total_tool_calls = sum(r["num_tool_calls"] for r in results)
 
     report = REPORT_HEADER.format(
@@ -253,20 +273,22 @@ async def run_evaluation(
         total_tool_calls=total_tool_calls,
     )
 
-    report += "".join([
-        TASK_TEMPLATE.format(
-            task_num=i + 1,
-            question=qa_pair["question"],
-            expected_answer=qa_pair["answer"],
-            actual_answer=result["actual"] or "N/A",
-            correct_indicator="✅" if result["score"] else "❌",
-            total_duration=result["total_duration"],
-            tool_calls=json.dumps(result["tool_calls"], indent=2),
-            summary=result["summary"] or "N/A",
-            feedback=result["feedback"] or "N/A",
-        )
-        for i, (qa_pair, result) in enumerate(zip(qa_pairs, results))
-    ])
+    report += "".join(
+        [
+            TASK_TEMPLATE.format(
+                task_num=i + 1,
+                question=qa_pair["question"],
+                expected_answer=qa_pair["answer"],
+                actual_answer=result["actual"] or "N/A",
+                correct_indicator="✅" if result["score"] else "❌",
+                total_duration=result["total_duration"],
+                tool_calls=json.dumps(result["tool_calls"], indent=2),
+                summary=result["summary"] or "N/A",
+                feedback=result["feedback"] or "N/A",
+            )
+            for i, (qa_pair, result) in enumerate(zip(qa_pairs, results))
+        ]
+    )
 
     return report
 
@@ -319,19 +341,50 @@ Examples:
     )
 
     parser.add_argument("eval_file", type=Path, help="Path to evaluation XML file")
-    parser.add_argument("-t", "--transport", choices=["stdio", "sse", "http"], default="stdio", help="Transport type (default: stdio)")
-    parser.add_argument("-m", "--model", default="claude-3-7-sonnet-20250219", help="Claude model to use (default: claude-3-7-sonnet-20250219)")
+    parser.add_argument(
+        "-t",
+        "--transport",
+        choices=["stdio", "sse", "http"],
+        default="stdio",
+        help="Transport type (default: stdio)",
+    )
+    parser.add_argument(
+        "-m",
+        "--model",
+        default="claude-3-7-sonnet-20250219",
+        help="Claude model to use (default: claude-3-7-sonnet-20250219)",
+    )
 
     stdio_group = parser.add_argument_group("stdio options")
-    stdio_group.add_argument("-c", "--command", help="Command to run MCP server (stdio only)")
-    stdio_group.add_argument("-a", "--args", nargs="+", help="Arguments for the command (stdio only)")
-    stdio_group.add_argument("-e", "--env", nargs="+", help="Environment variables in KEY=VALUE format (stdio only)")
+    stdio_group.add_argument(
+        "-c", "--command", help="Command to run MCP server (stdio only)"
+    )
+    stdio_group.add_argument(
+        "-a", "--args", nargs="+", help="Arguments for the command (stdio only)"
+    )
+    stdio_group.add_argument(
+        "-e",
+        "--env",
+        nargs="+",
+        help="Environment variables in KEY=VALUE format (stdio only)",
+    )
 
     remote_group = parser.add_argument_group("sse/http options")
     remote_group.add_argument("-u", "--url", help="MCP server URL (sse/http only)")
-    remote_group.add_argument("-H", "--header", nargs="+", dest="headers", help="HTTP headers in 'Key: Value' format (sse/http only)")
+    remote_group.add_argument(
+        "-H",
+        "--header",
+        nargs="+",
+        dest="headers",
+        help="HTTP headers in 'Key: Value' format (sse/http only)",
+    )
 
-    parser.add_argument("-o", "--output", type=Path, help="Output file for evaluation report (default: stdout)")
+    parser.add_argument(
+        "-o",
+        "--output",
+        type=Path,
+        help="Output file for evaluation report (default: stdout)",
+    )
 
     args = parser.parse_args()
 

claude_mpm/skills/bundled/main/skill-creator/scripts/init_skill.py

@@ -187,7 +187,7 @@ Note: This is a text placeholder. Actual assets can be any file type.
 
 def title_case_skill_name(skill_name):
     """Convert hyphenated skill name to Title Case for display."""
-    return ' '.join(word.capitalize() for word in skill_name.split('-'))
+    return " ".join(word.capitalize() for word in skill_name.split("-"))
 
 
 def init_skill(skill_name, path):
@@ -220,11 +220,10 @@ def init_skill(skill_name, path):
     # Create SKILL.md from template
     skill_title = title_case_skill_name(skill_name)
     skill_content = SKILL_TEMPLATE.format(
-        skill_name=skill_name,
-        skill_title=skill_title
+        skill_name=skill_name, skill_title=skill_title
     )
 
-    skill_md_path = skill_dir / 'SKILL.md'
+    skill_md_path = skill_dir / "SKILL.md"
     try:
         skill_md_path.write_text(skill_content)
         print("✅ Created SKILL.md")
@@ -235,24 +234,24 @@ def init_skill(skill_name, path):
     # Create resource directories with example files
     try:
         # Create scripts/ directory with example script
-        scripts_dir = skill_dir / 'scripts'
+        scripts_dir = skill_dir / "scripts"
         scripts_dir.mkdir(exist_ok=True)
-        example_script = scripts_dir / 'example.py'
+        example_script = scripts_dir / "example.py"
         example_script.write_text(EXAMPLE_SCRIPT.format(skill_name=skill_name))
         example_script.chmod(0o755)
         print("✅ Created scripts/example.py")
 
         # Create references/ directory with example reference doc
-        references_dir = skill_dir / 'references'
+        references_dir = skill_dir / "references"
         references_dir.mkdir(exist_ok=True)
-        example_reference = references_dir / 'api_reference.md'
+        example_reference = references_dir / "api_reference.md"
         example_reference.write_text(EXAMPLE_REFERENCE.format(skill_title=skill_title))
         print("✅ Created references/api_reference.md")
 
         # Create assets/ directory with example asset placeholder
-        assets_dir = skill_dir / 'assets'
+        assets_dir = skill_dir / "assets"
         assets_dir.mkdir(exist_ok=True)
-        example_asset = assets_dir / 'example_asset.txt'
+        example_asset = assets_dir / "example_asset.txt"
         example_asset.write_text(EXAMPLE_ASSET)
         print("✅ Created assets/example_asset.txt")
     except Exception as e:
@@ -263,14 +262,16 @@ def init_skill(skill_name, path):
     print(f"\n✅ Skill '{skill_name}' initialized successfully at {skill_dir}")
     print("\nNext steps:")
     print("1. Edit SKILL.md to complete the TODO items and update the description")
-    print("2. Customize or delete the example files in scripts/, references/, and assets/")
+    print(
+        "2. Customize or delete the example files in scripts/, references/, and assets/"
+    )
     print("3. Run the validator when ready to check the skill structure")
 
     return skill_dir
 
 
 def main():
-    if len(sys.argv) < 4 or sys.argv[2] != '--path':
+    if len(sys.argv) < 4 or sys.argv[2] != "--path":
         print("Usage: init_skill.py <skill-name> --path <path>")
         print("\nSkill name requirements:")
         print("  - Hyphen-case identifier (e.g., 'data-analyzer')")

claude_mpm/skills/bundled/main/skill-creator/scripts/package_skill.py

@@ -66,9 +66,9 @@ def package_skill(skill_path, output_dir=None):
 
     # Create the zip file
     try:
-        with zipfile.ZipFile(zip_filename, 'w', zipfile.ZIP_DEFLATED) as zipf:
+        with zipfile.ZipFile(zip_filename, "w", zipfile.ZIP_DEFLATED) as zipf:
             # Walk through the skill directory
-            for file_path in skill_path.rglob('*'):
+            for file_path in skill_path.rglob("*"):
                 if file_path.is_file():
                     # Calculate the relative path within the zip
                     arcname = file_path.relative_to(skill_path.parent)
@@ -85,7 +85,9 @@ def package_skill(skill_path, output_dir=None):
 
 def main():
     if len(sys.argv) < 2:
-        print("Usage: python utils/package_skill.py <path/to/skill-folder> [output-directory]")
+        print(
+            "Usage: python utils/package_skill.py <path/to/skill-folder> [output-directory]"
+        )
         print("\nExample:")
         print("  python utils/package_skill.py skills/public/my-skill")
         print("  python utils/package_skill.py skills/public/my-skill ./dist")

claude_mpm/skills/bundled/main/skill-creator/scripts/quick_validate.py

@@ -13,48 +13,55 @@ def validate_skill(skill_path):
     skill_path = Path(skill_path)
 
     # Check SKILL.md exists
-    skill_md = skill_path / 'SKILL.md'
+    skill_md = skill_path / "SKILL.md"
     if not skill_md.exists():
         return False, "SKILL.md not found"
 
     # Read and validate frontmatter
     content = skill_md.read_text()
-    if not content.startswith('---'):
+    if not content.startswith("---"):
         return False, "No YAML frontmatter found"
 
     # Extract frontmatter
-    match = re.match(r'^---\n(.*?)\n---', content, re.DOTALL)
+    match = re.match(r"^---\n(.*?)\n---", content, re.DOTALL)
     if not match:
         return False, "Invalid frontmatter format"
 
     frontmatter = match.group(1)
 
     # Check required fields
-    if 'name:' not in frontmatter:
+    if "name:" not in frontmatter:
         return False, "Missing 'name' in frontmatter"
-    if 'description:' not in frontmatter:
+    if "description:" not in frontmatter:
         return False, "Missing 'description' in frontmatter"
 
     # Extract name for validation
-    name_match = re.search(r'name:\s*(.+)', frontmatter)
+    name_match = re.search(r"name:\s*(.+)", frontmatter)
     if name_match:
         name = name_match.group(1).strip()
         # Check naming convention (hyphen-case: lowercase with hyphens)
-        if not re.match(r'^[a-z0-9-]+$', name):
-            return False, f"Name '{name}' should be hyphen-case (lowercase letters, digits, and hyphens only)"
-        if name.startswith('-') or name.endswith('-') or '--' in name:
-            return False, f"Name '{name}' cannot start/end with hyphen or contain consecutive hyphens"
+        if not re.match(r"^[a-z0-9-]+$", name):
+            return (
+                False,
+                f"Name '{name}' should be hyphen-case (lowercase letters, digits, and hyphens only)",
+            )
+        if name.startswith("-") or name.endswith("-") or "--" in name:
+            return (
+                False,
+                f"Name '{name}' cannot start/end with hyphen or contain consecutive hyphens",
+            )
 
     # Extract and validate description
-    desc_match = re.search(r'description:\s*(.+)', frontmatter)
+    desc_match = re.search(r"description:\s*(.+)", frontmatter)
     if desc_match:
         description = desc_match.group(1).strip()
         # Check for angle brackets
-        if '<' in description or '>' in description:
+        if "<" in description or ">" in description:
             return False, "Description cannot contain angle brackets (< or >)"
 
     return True, "Skill is valid!"
 
+
 if __name__ == "__main__":
     if len(sys.argv) != 2:
         print("Usage: python quick_validate.py <skill_directory>")

claude_mpm/skills/bundled/performance-profiling.md

@@ -433,6 +433,12 @@ def sort_items(items):
 
 ### Load Testing
 
+> **Note:** Locust is an optional dependency. Install it separately if you need load testing capabilities:
+> ```bash
+> pip install "claude-mpm[agents-load-testing]"
+> ```
+> Or install locust directly: `pip install locust>=2.15.0`
+
 ```python
 # Using locust for load testing
 from locust import HttpUser, task, between

claude_mpm/skills/bundled/testing/webapp-testing/examples/console_logging.py

@@ -2,13 +2,13 @@ from playwright.sync_api import sync_playwright
 
 # Example: Capturing console logs during browser automation
 
-url = 'http://localhost:5173'  # Replace with your URL
+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})
+    page = browser.new_page(viewport={"width": 1920, "height": 1080})
 
     # Set up console log capture
     def handle_console_message(msg):
@@ -19,17 +19,17 @@ with sync_playwright() as p:
 
     # Navigate to page
     page.goto(url)
-    page.wait_for_load_state('networkidle')
+    page.wait_for_load_state("networkidle")
 
     # Interact with the page (triggers console logs)
-    page.click('text=Dashboard')
+    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))
+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")

claude_mpm/skills/bundled/testing/webapp-testing/examples/element_discovery.py

@@ -7,34 +7,38 @@ with sync_playwright() as p:
     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')
+    page.goto("http://localhost:5173")
+    page.wait_for_load_state("networkidle")
 
     # Discover all buttons on the page
-    buttons = page.locator('button').all()
+    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()
+    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')
+        href = link.get_attribute("href")
         print(f"  - {text} -> {href}")
 
     # Discover input fields
-    inputs = page.locator('input, textarea, select').all()
+    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'
+        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)
+    page.screenshot(path="/tmp/page_discovery.png", full_page=True)
     print("\nScreenshot saved to /tmp/page_discovery.png")
 
     browser.close()

claude_mpm/skills/bundled/testing/webapp-testing/examples/static_html_automation.py

@@ -4,30 +4,30 @@ 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}'
+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})
+    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)
+    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')
+    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)
+    page.screenshot(path="/mnt/user-data/outputs/after_submit.png", full_page=True)
 
     browser.close()
 

claude_mpm/skills/bundled/testing/webapp-testing/scripts/with_server.py

@@ -26,7 +26,7 @@ def is_server_ready(port, timeout=30):
     start_time = time.time()
     while time.time() - start_time < timeout:
         try:
-            with socket.create_connection(('localhost', port), timeout=1):
+            with socket.create_connection(("localhost", port), timeout=1):
                 return True
         except (OSError, ConnectionRefusedError):
             time.sleep(0.5)
@@ -34,16 +34,36 @@ def is_server_ready(port, timeout=30):
 
 
 def main():
-    parser = argparse.ArgumentParser(description='Run command with one or more servers')
-    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('--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')
+    parser = argparse.ArgumentParser(description="Run command with one or more servers")
+    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(
+        "--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] == '--':
+    if args.command and args.command[0] == "--":
         args.command = args.command[1:]
 
     if not args.command:
@@ -57,28 +77,30 @@ def main():
 
     servers = []
     for cmd, port in zip(args.servers, args.ports):
-        servers.append({'cmd': cmd, 'port': port})
+        servers.append({"cmd": cmd, "port": port})
 
     server_processes = []
 
     try:
         # Start all servers
         for i, server in enumerate(servers):
-            print(f"Starting server {i+1}/{len(servers)}: {server['cmd']}")
+            print(f"Starting server {i + 1}/{len(servers)}: {server['cmd']}")
 
             # Use shell=True to support commands with cd and &&
             process = subprocess.Popen(
-                server['cmd'],
+                server["cmd"],
                 shell=True,
                 stdout=subprocess.PIPE,
-                stderr=subprocess.PIPE
+                stderr=subprocess.PIPE,
             )
             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")
+            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']}")
 
@@ -99,9 +121,9 @@ def main():
             except subprocess.TimeoutExpired:
                 process.kill()
                 process.wait()
-            print(f"Server {i+1} stopped")
+            print(f"Server {i + 1} stopped")
         print("All servers stopped")
 
 
-if __name__ == '__main__':
+if __name__ == "__main__":
     main()