qaforge-mcp 1.0.0__tar.gz

qaforge_mcp-1.0.0/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Sahil
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

qaforge_mcp-1.0.0/PKG-INFO

@@ -0,0 +1,83 @@
+Metadata-Version: 2.4
+Name: qaforge-mcp
+Version: 1.0.0
+Summary: The World's First All-in-One QA MCP Server — 12 QA tools for Claude Code
+Author-email: Sahil <sahil804.2017@gmail.com>
+License: MIT
+Keywords: mcp,qa,testing,playwright,jira,security,k6
+Classifier: Development Status :: 4 - Beta
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Requires-Dist: fastmcp>=2.0.0
+Requires-Dist: anthropic>=0.40.0
+Requires-Dist: httpx>=0.27.0
+Requires-Dist: playwright>=1.45.0
+Requires-Dist: pyyaml>=6.0
+Requires-Dist: faker>=26.0.0
+Requires-Dist: python-dotenv>=1.0.0
+Dynamic: license-file
+
+# QAForge MCP
+
+The world's first all-in-one QA engineering MCP server — 12 QA tools for Claude Code, in one place.
+
+Generate test cases, run security scans, detect flaky tests, diff browsers, check accessibility, baseline performance, and more — all from natural language, inside Claude.
+
+## Tools
+
+| # | Tool | What it does |
+|---|------|---------------|
+| 1 | `generate_test_cases` | FRD/Swagger → numbered test cases with priority + coverage gaps |
+| 2 | `detect_flaky_tests` | Statistical flaky-test detection across JUnit XML runs, AI root-cause |
+| 3 | `generate_security_tests` | OWASP Top 10 Postman collection + k6 security script |
+| 4 | `narrate_report` | JUnit/Allure report → stakeholder-ready narrative, optional Slack post |
+| 5 | `diff_browsers` | Cross-browser (Chrome/Firefox/WebKit) diffing via Playwright |
+| 6 | `ai_test_executor` | Executes structured test cases against a live URL |
+| 7 | `bug_report_generator` | AI bug report + optional Jira ticket creation |
+| 8 | `regression_impact_analyzer` | git diff → impacted test areas + risk levels |
+| 9 | `accessibility_checker` | WCAG 2.1 audit via axe-core, AI fix suggestions |
+| 10 | `performance_baseline_mcp` | k6 load test, P50–P99, baseline regression alerts |
+| 11 | `environment_health_checker` | Pre-test service health checks, Slack alerts |
+| 12 | `test_data_generator` | Faker-based test data + edge cases + blockchain fields |
+
+## Install
+
+```bash
+pip install qaforge-mcp
+playwright install chromium firefox webkit   # needed for browser/accessibility tools
+```
+
+Optionally install [k6](https://k6.io/docs/getting-started/installation/) for the performance tools.
+
+## Register with Claude Code
+
+```bash
+claude mcp add --scope user qaforge -e ANTHROPIC_API_KEY=your-key-here -- python -m qaforge_mcp
+```
+
+This makes all 12 tools available in every Claude Code session on your machine.
+
+### Optional integrations
+
+Add any of these to the same `-e` flags (or a `.env` file next to your working directory) to unlock more:
+
+| Variable | Enables |
+|---|---|
+| `ANTHROPIC_API_KEY` | AI-powered analysis (test generation, root-cause classification, bug reports) |
+| `JIRA_URL`, `JIRA_EMAIL`, `JIRA_TOKEN`, `JIRA_PROJECT_KEY` | Auto-create Jira tickets from `bug_report_generator` |
+| `SLACK_WEBHOOK` | Post test reports and environment alerts to Slack |
+
+Tools work without any of these configured — AI-dependent tools fall back to non-AI output, and Jira/Slack features simply no-op.
+
+## Requirements
+
+- Python 3.11+
+- [Playwright](https://playwright.dev/) browsers for `diff_browsers`, `accessibility_checker`, `ai_test_executor`
+- [k6](https://k6.io/) for `performance_baseline_mcp` and the security k6 script
+
+## License
+
+MIT

qaforge_mcp-1.0.0/README.md

@@ -0,0 +1,61 @@
+# QAForge MCP
+
+The world's first all-in-one QA engineering MCP server — 12 QA tools for Claude Code, in one place.
+
+Generate test cases, run security scans, detect flaky tests, diff browsers, check accessibility, baseline performance, and more — all from natural language, inside Claude.
+
+## Tools
+
+| # | Tool | What it does |
+|---|------|---------------|
+| 1 | `generate_test_cases` | FRD/Swagger → numbered test cases with priority + coverage gaps |
+| 2 | `detect_flaky_tests` | Statistical flaky-test detection across JUnit XML runs, AI root-cause |
+| 3 | `generate_security_tests` | OWASP Top 10 Postman collection + k6 security script |
+| 4 | `narrate_report` | JUnit/Allure report → stakeholder-ready narrative, optional Slack post |
+| 5 | `diff_browsers` | Cross-browser (Chrome/Firefox/WebKit) diffing via Playwright |
+| 6 | `ai_test_executor` | Executes structured test cases against a live URL |
+| 7 | `bug_report_generator` | AI bug report + optional Jira ticket creation |
+| 8 | `regression_impact_analyzer` | git diff → impacted test areas + risk levels |
+| 9 | `accessibility_checker` | WCAG 2.1 audit via axe-core, AI fix suggestions |
+| 10 | `performance_baseline_mcp` | k6 load test, P50–P99, baseline regression alerts |
+| 11 | `environment_health_checker` | Pre-test service health checks, Slack alerts |
+| 12 | `test_data_generator` | Faker-based test data + edge cases + blockchain fields |
+
+## Install
+
+```bash
+pip install qaforge-mcp
+playwright install chromium firefox webkit   # needed for browser/accessibility tools
+```
+
+Optionally install [k6](https://k6.io/docs/getting-started/installation/) for the performance tools.
+
+## Register with Claude Code
+
+```bash
+claude mcp add --scope user qaforge -e ANTHROPIC_API_KEY=your-key-here -- python -m qaforge_mcp
+```
+
+This makes all 12 tools available in every Claude Code session on your machine.
+
+### Optional integrations
+
+Add any of these to the same `-e` flags (or a `.env` file next to your working directory) to unlock more:
+
+| Variable | Enables |
+|---|---|
+| `ANTHROPIC_API_KEY` | AI-powered analysis (test generation, root-cause classification, bug reports) |
+| `JIRA_URL`, `JIRA_EMAIL`, `JIRA_TOKEN`, `JIRA_PROJECT_KEY` | Auto-create Jira tickets from `bug_report_generator` |
+| `SLACK_WEBHOOK` | Post test reports and environment alerts to Slack |
+
+Tools work without any of these configured — AI-dependent tools fall back to non-AI output, and Jira/Slack features simply no-op.
+
+## Requirements
+
+- Python 3.11+
+- [Playwright](https://playwright.dev/) browsers for `diff_browsers`, `accessibility_checker`, `ai_test_executor`
+- [k6](https://k6.io/) for `performance_baseline_mcp` and the security k6 script
+
+## License
+
+MIT

qaforge_mcp-1.0.0/pyproject.toml

@@ -0,0 +1,34 @@
+[build-system]
+requires = ["setuptools>=61", "wheel"]
+build-backend = "setuptools.build_meta"
+
+[project]
+name = "qaforge-mcp"
+version = "1.0.0"
+description = "The World's First All-in-One QA MCP Server — 12 QA tools for Claude Code"
+readme = "README.md"
+requires-python = ">=3.11"
+license = { text = "MIT" }
+authors = [{ name = "Sahil", email = "sahil804.2017@gmail.com" }]
+keywords = ["mcp", "qa", "testing", "playwright", "jira", "security", "k6"]
+classifiers = [
+    "Development Status :: 4 - Beta",
+    "Programming Language :: Python :: 3.11",
+    "Topic :: Software Development :: Testing",
+]
+
+dependencies = [
+    "fastmcp>=2.0.0",
+    "anthropic>=0.40.0",
+    "httpx>=0.27.0",
+    "playwright>=1.45.0",
+    "pyyaml>=6.0",
+    "faker>=26.0.0",
+    "python-dotenv>=1.0.0",
+]
+
+[project.scripts]
+qaforge-mcp = "qaforge_mcp.__main__:main"
+
+[tool.hatch.build.targets.wheel]
+packages = ["qaforge_mcp"]

qaforge_mcp-1.0.0/qaforge_mcp/__init__.py

@@ -0,0 +1,4 @@
+"""QAForge MCP — The World's First All-in-One QA Engineering MCP Server."""
+
+__version__ = "1.0.0"
+__author__ = "Sahil"

qaforge_mcp-1.0.0/qaforge_mcp/__main__.py

@@ -0,0 +1,10 @@
+"""Entry point for QAForge MCP server."""
+
+
+def main():
+    from .server import mcp
+    mcp.run()
+
+
+if __name__ == "__main__":
+    main()

qaforge_mcp-1.0.0/qaforge_mcp/config.py

@@ -0,0 +1,35 @@
+import os
+from pathlib import Path
+from dotenv import load_dotenv
+
+load_dotenv()
+
+
+class Config:
+    def __init__(self):
+        self.anthropic_api_key: str = os.getenv("ANTHROPIC_API_KEY", "")
+        self.claude_model: str = os.getenv("CLAUDE_MODEL", "claude-sonnet-4-6")
+
+        self.jira_url: str = os.getenv("JIRA_URL", "").rstrip("/")
+        self.jira_email: str = os.getenv("JIRA_EMAIL", "")
+        self.jira_token: str = os.getenv("JIRA_TOKEN", "")
+        self.jira_project_key: str = os.getenv("JIRA_PROJECT_KEY", "QA")
+
+        self.slack_webhook_url: str = os.getenv("SLACK_WEBHOOK", "")
+
+        self.baseline_file: Path = Path(os.getenv("BASELINE_FILE", "qaforge_baselines.json"))
+
+    @property
+    def jira_configured(self) -> bool:
+        return bool(self.jira_url and self.jira_token)
+
+    @property
+    def slack_configured(self) -> bool:
+        return bool(self.slack_webhook_url)
+
+    @property
+    def ai_configured(self) -> bool:
+        return bool(self.anthropic_api_key)
+
+
+config = Config()

qaforge_mcp-1.0.0/qaforge_mcp/integrations/jira.py

@@ -0,0 +1,66 @@
+import base64
+from typing import Optional
+import httpx
+from ..config import config
+
+
+def _auth_header() -> str:
+    credentials = f"{config.jira_email}:{config.jira_token}"
+    return "Basic " + base64.b64encode(credentials.encode()).decode()
+
+
+async def create_issue(
+    summary: str,
+    description: str,
+    issue_type: str = "Bug",
+    priority: str = "High",
+    labels: Optional[list[str]] = None,
+    assignee_account_id: Optional[str] = None,
+) -> dict:
+    if not config.jira_configured:
+        return {"error": "Jira not configured. Set JIRA_URL, JIRA_EMAIL, JIRA_TOKEN env vars."}
+
+    headers = {
+        "Authorization": _auth_header(),
+        "Content-Type": "application/json",
+        "Accept": "application/json",
+    }
+
+    fields: dict = {
+        "project": {"key": config.jira_project_key},
+        "summary": summary,
+        "description": {
+            "type": "doc",
+            "version": 1,
+            "content": [
+                {
+                    "type": "paragraph",
+                    "content": [{"type": "text", "text": description}],
+                }
+            ],
+        },
+        "issuetype": {"name": issue_type},
+        "priority": {"name": priority},
+    }
+
+    if labels:
+        fields["labels"] = labels
+    if assignee_account_id:
+        fields["assignee"] = {"accountId": assignee_account_id}
+
+    payload = {"fields": fields}
+
+    async with httpx.AsyncClient(timeout=30) as client:
+        resp = await client.post(
+            f"{config.jira_url}/rest/api/3/issue",
+            headers=headers,
+            json=payload,
+        )
+        if resp.status_code == 201:
+            data = resp.json()
+            return {
+                "key": data["key"],
+                "id": data["id"],
+                "url": f"{config.jira_url}/browse/{data['key']}",
+            }
+        return {"error": f"Jira API error {resp.status_code}: {resp.text[:500]}"}

qaforge_mcp-1.0.0/qaforge_mcp/integrations/k6_runner.py

@@ -0,0 +1,137 @@
+import asyncio
+import json
+import os
+import shutil
+import tempfile
+from pathlib import Path
+from typing import Optional
+
+_K6_CANDIDATES = [
+    "k6",
+    r"C:\Program Files\k6\k6.exe",
+    r"C:\Program Files (x86)\k6\k6.exe",
+    str(Path.home() / "AppData" / "Local" / "Microsoft" / "WinGet" / "Packages" / "GrafanaLabs.k6_Microsoft.Winget.Source_8wekyb3d8bbwe" / "k6.exe"),
+]
+
+
+def _find_k6() -> str:
+    if found := shutil.which("k6"):
+        return found
+    for candidate in _K6_CANDIDATES:
+        if Path(candidate).exists():
+            return candidate
+    return "k6"
+
+
+def generate_k6_script(
+    endpoints: list[dict],
+    vus: int = 10,
+    duration: str = "30s",
+    baseline_thresholds: Optional[dict] = None,
+) -> str:
+    endpoint_calls = []
+    for ep in endpoints:
+        method = ep.get("method", "GET").upper()
+        url = ep.get("url", "")
+        headers = ep.get("headers", {})
+        body = ep.get("body", None)
+
+        url_js = json.dumps(url)
+        headers_js = json.dumps(headers)
+        if method == "GET":
+            endpoint_calls.append(f'    http.get({url_js}, {{headers: {headers_js}}});')
+        else:
+            body_js = json.dumps(body) if body else "null"
+            endpoint_calls.append(
+                f'    http.{method.lower()}({url_js}, JSON.stringify({body_js}), {{headers: {headers_js}}});'
+            )
+
+    calls_block = "\n".join(endpoint_calls) if endpoint_calls else '    http.get(__ENV.TARGET_URL || "http://localhost:3000");'
+
+    thresholds = baseline_thresholds or {
+        "http_req_duration": ["p(90)<2000", "p(95)<3000"],
+        "http_req_failed": ["rate<0.05"],
+    }
+    thresholds_js = json.dumps(thresholds, indent=4)
+
+    return f"""import http from 'k6/http';
+import {{ check, sleep }} from 'k6';
+
+export const options = {{
+    vus: {vus},
+    duration: '{duration}',
+    thresholds: {thresholds_js},
+}};
+
+export default function () {{
+{calls_block}
+    sleep(1);
+}}
+"""
+
+
+async def run_k6(script_content: str, output_json: bool = True) -> dict:
+    with tempfile.TemporaryDirectory() as tmpdir:
+        script_path = Path(tmpdir) / "test.js"
+        output_path = Path(tmpdir) / "results.json"
+        script_path.write_text(script_content)
+
+        cmd = [_find_k6(), "run"]
+        if output_json:
+            cmd += ["--out", f"json={output_path}"]
+        cmd.append(str(script_path))
+
+        try:
+            proc = await asyncio.create_subprocess_exec(
+                *cmd,
+                stdout=asyncio.subprocess.PIPE,
+                stderr=asyncio.subprocess.PIPE,
+                cwd=tmpdir,
+            )
+            stdout, stderr = await asyncio.wait_for(proc.communicate(), timeout=300)
+        except FileNotFoundError:
+            return {"error": "k6 not installed. Install from https://k6.io/docs/getting-started/installation/"}
+        except asyncio.TimeoutError:
+            proc.kill()
+            return {"error": "k6 run timed out after 5 minutes"}
+
+        stdout_text = stdout.decode(errors="replace")
+        stderr_text = stderr.decode(errors="replace")
+
+        metrics = _parse_k6_stdout(stdout_text)
+        metrics["exit_code"] = proc.returncode
+        metrics["stdout"] = stdout_text[-3000:]
+        if proc.returncode != 0:
+            metrics["stderr"] = stderr_text[-1000:]
+
+        return metrics
+
+
+def _parse_k6_stdout(output: str) -> dict:
+    metrics: dict = {}
+    for line in output.splitlines():
+        if "http_req_duration" in line and "avg=" in line:
+            metrics["raw_duration_line"] = line.strip()
+            for part in line.split():
+                for key in ["avg", "min", "med", "max", "p(90)", "p(95)", "p(99)"]:
+                    if part.startswith(key + "="):
+                        val_str = part.split("=")[1].replace("ms", "").replace("s", "")
+                        try:
+                            metrics[key.replace("(", "").replace(")", "")] = float(val_str)
+                        except ValueError:
+                            pass
+        elif "http_req_failed" in line and "rate=" in line:
+            for part in line.split():
+                if part.startswith("rate="):
+                    try:
+                        metrics["failure_rate"] = float(part.split("=")[1].rstrip("%")) / 100
+                    except ValueError:
+                        pass
+        elif "http_reqs" in line and "rate=" in line:
+            for part in line.split():
+                if part.startswith("rate="):
+                    try:
+                        metrics["rps"] = float(part.split("=")[1].split("/")[0])
+                    except ValueError:
+                        pass
+    return metrics

qaforge_mcp-1.0.0/qaforge_mcp/integrations/playwright_runner.py

@@ -0,0 +1,114 @@
+import asyncio
+import base64
+from typing import Optional
+from playwright.async_api import async_playwright, Browser, BrowserContext, Page
+
+
+async def get_page_snapshot(url: str, browser_type: str = "chromium") -> dict:
+    async with async_playwright() as p:
+        launcher = getattr(p, browser_type)
+        browser: Browser = await launcher.launch(headless=True)
+        context: BrowserContext = await browser.new_context()
+        page: Page = await context.new_page()
+        errors: list[str] = []
+        page.on("pageerror", lambda e: errors.append(str(e)))
+
+        try:
+            await page.goto(url, wait_until="networkidle", timeout=30000)
+            title = await page.title()
+            screenshot_bytes = await page.screenshot(full_page=True)
+            screenshot_b64 = base64.b64encode(screenshot_bytes).decode()
+            dom_snapshot = await page.evaluate("document.documentElement.outerHTML")
+            perf = await page.evaluate("""() => {
+                const nav = performance.getEntriesByType('navigation')[0];
+                return nav ? {
+                    dom_content_loaded: Math.round(nav.domContentLoadedEventEnd),
+                    load: Math.round(nav.loadEventEnd)
+                } : {};
+            }""")
+            return {
+                "browser": browser_type,
+                "url": url,
+                "title": title,
+                "screenshot_b64": screenshot_b64,
+                "dom_length": len(dom_snapshot),
+                "dom_snippet": dom_snapshot[:2000],
+                "js_errors": errors,
+                "performance_ms": perf,
+            }
+        except Exception as e:
+            return {"browser": browser_type, "url": url, "error": str(e)}
+        finally:
+            await browser.close()
+
+
+async def run_axe_audit(url: str) -> dict:
+    async with async_playwright() as p:
+        browser: Browser = await p.chromium.launch(headless=True)
+        page: Page = await browser.new_page()
+        try:
+            await page.goto(url, wait_until="networkidle", timeout=30000)
+            await page.add_script_tag(url="https://cdnjs.cloudflare.com/ajax/libs/axe-core/4.9.1/axe.min.js")
+            await page.wait_for_function("typeof axe !== 'undefined'", timeout=10000)
+            results = await page.evaluate("""async () => {
+                const result = await axe.run();
+                return {
+                    violations: result.violations,
+                    passes: result.passes.length,
+                    incomplete: result.incomplete.length,
+                    inapplicable: result.inapplicable.length
+                };
+            }""")
+            return results
+        except Exception as e:
+            return {"error": str(e), "violations": []}
+        finally:
+            await browser.close()
+
+
+async def execute_steps(url: str, steps: list[str]) -> dict:
+    """Execute a list of natural-language-like Playwright steps on a URL."""
+    async with async_playwright() as p:
+        browser: Browser = await p.chromium.launch(headless=True)
+        page: Page = await browser.new_page()
+        executed: list[dict] = []
+        try:
+            await page.goto(url, wait_until="networkidle", timeout=30000)
+            for step in steps:
+                step_lower = step.lower().strip()
+                try:
+                    if step_lower.startswith("click "):
+                        selector = step[6:].strip().strip("'\"")
+                        await page.click(selector, timeout=10000)
+                        executed.append({"step": step, "status": "pass"})
+                    elif step_lower.startswith("fill "):
+                        parts = step[5:].split(" with ", 1)
+                        if len(parts) == 2:
+                            selector = parts[0].strip().strip("'\"")
+                            value = parts[1].strip().strip("'\"")
+                            await page.fill(selector, value, timeout=10000)
+                            executed.append({"step": step, "status": "pass"})
+                    elif step_lower.startswith("assert visible "):
+                        selector = step[15:].strip().strip("'\"")
+                        await page.wait_for_selector(selector, state="visible", timeout=10000)
+                        executed.append({"step": step, "status": "pass"})
+                    elif step_lower.startswith("assert text "):
+                        text = step[12:].strip().strip("'\"")
+                        await page.wait_for_function(
+                            f"document.body.innerText.includes({repr(text)})", timeout=10000
+                        )
+                        executed.append({"step": step, "status": "pass"})
+                    elif step_lower.startswith("navigate "):
+                        nav_url = step[9:].strip()
+                        await page.goto(nav_url, wait_until="networkidle", timeout=30000)
+                        executed.append({"step": step, "status": "pass"})
+                    else:
+                        executed.append({"step": step, "status": "skipped", "reason": "unrecognized step"})
+                except Exception as e:
+                    executed.append({"step": step, "status": "fail", "error": str(e)})
+            final_url = page.url
+            return {"steps": executed, "final_url": final_url}
+        except Exception as e:
+            return {"steps": executed, "error": str(e)}
+        finally:
+            await browser.close()

qaforge_mcp-1.0.0/qaforge_mcp/integrations/slack.py

@@ -0,0 +1,43 @@
+from typing import Optional
+import httpx
+from ..config import config
+
+
+async def send_message(text: str, blocks: Optional[list] = None) -> dict:
+    if not config.slack_configured:
+        return {"error": "Slack not configured. Set SLACK_WEBHOOK env var."}
+
+    payload: dict = {"text": text}
+    if blocks:
+        payload["blocks"] = blocks
+
+    async with httpx.AsyncClient(timeout=15) as client:
+        resp = await client.post(config.slack_webhook_url, json=payload)
+        if resp.status_code == 200:
+            return {"status": "sent"}
+        return {"error": f"Slack error {resp.status_code}: {resp.text}"}
+
+
+async def send_qa_report(summary: str, pass_count: int, fail_count: int, channel_note: str = "") -> dict:
+    blocks = [
+        {
+            "type": "header",
+            "text": {"type": "plain_text", "text": "QAForge Test Report"},
+        },
+        {
+            "type": "section",
+            "fields": [
+                {"type": "mrkdwn", "text": f"*Passed:* {pass_count}"},
+                {"type": "mrkdwn", "text": f"*Failed:* {fail_count}"},
+            ],
+        },
+        {
+            "type": "section",
+            "text": {"type": "mrkdwn", "text": summary},
+        },
+    ]
+    if channel_note:
+        blocks.append({"type": "context", "elements": [{"type": "mrkdwn", "text": channel_note}]})
+
+    return await send_message(text=f"QA Report: {pass_count} passed, {fail_count} failed", blocks=blocks)
+