qaforge-mcp 1.0.0__py3-none-any.whl

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/__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/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/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/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/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/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)
+