ai-testing-swarm 0.1.1__py3-none-any.whl

ai_testing_swarm/__init__.py

@@ -0,0 +1 @@
+__version__ = "0.1.0"

ai_testing_swarm/agents/execution_agent.py

@@ -0,0 +1,64 @@
+import requests
+from copy import deepcopy
+
+
+class ExecutionAgent:
+    def apply_mutation(self, data: dict, mutation: dict):
+        if not mutation:
+            return deepcopy(data)
+
+        data = deepcopy(data)
+        key = mutation["path"][0]
+        op = mutation["operation"]
+
+        if op == "REMOVE":
+            data.pop(key, None)
+        elif op == "REPLACE":
+            data[key] = mutation["new_value"]
+
+        return data
+
+    def execute(self, request: dict, test: dict):
+        mutation = test.get("mutation")
+
+        params = (
+            self.apply_mutation(request.get("params", {}), mutation)
+            if mutation and mutation.get("target") == "query"
+            else deepcopy(request.get("params", {}))
+        )
+
+        body = (
+            self.apply_mutation(request.get("body", {}), mutation)
+            if mutation and mutation.get("target") == "body"
+            else deepcopy(request.get("body", {}))
+        )
+
+        response = requests.request(
+            method=request["method"],
+            url=request["url"],
+            headers=request["headers"],
+            params=params or None,
+            json=None if request["method"] == "GET" else body,
+            timeout=10,
+        )
+
+        try:
+            body_snippet = response.json()
+        except Exception:
+            body_snippet = response.text
+
+        return {
+            "name": test["name"],  # 🔥 CANONICAL
+            "mutation": mutation,
+            "request": {
+                "method": request["method"],
+                "url": request["url"],
+                "headers": request["headers"],
+                "params": params,
+                "body": body if request["method"] != "GET" else None,
+            },
+            "response": {
+                "status_code": response.status_code,
+                "body_snippet": body_snippet,
+            },
+        }

ai_testing_swarm/agents/learning_agent.py

@@ -0,0 +1,29 @@
+import json
+import os
+
+DB = "memory/failure_memory.json"
+
+
+class LearningAgent:
+    def learn(self, test_name, reasoning):
+        os.makedirs(os.path.dirname(DB), exist_ok=True)
+
+        data = []
+
+        if os.path.exists(DB):
+            try:
+                with open(DB, "r") as f:
+                    content = f.read().strip()
+                    if content:
+                        data = json.loads(content)
+            except Exception:
+                # Corrupted file → reset
+                data = []
+
+        data.append({
+            "test": test_name,
+            "reason": reasoning
+        })
+
+        with open(DB, "w") as f:
+            json.dump(data, f, indent=2)

ai_testing_swarm/agents/llm_reasoning_agent.py

@@ -0,0 +1,162 @@
+"""
+LLMReasoningAgent
+
+⚠️ IMPORTANT DESIGN SHIFT (INTENTIONAL):
+
+- Correctness is NEVER decided by an LLM
+- Deterministic HTTP + mutation rules come FIRST
+- This file no longer REQUIRES OpenAI to function
+- LLM can be added later ONLY for explanation enrichment
+
+This fixes:
+- happy_path incorrectly marked FAILED
+- random "unknown" classifications
+- non-deterministic release decisions
+"""
+
+
+class LLMReasoningAgent:
+    """
+    Classifies API test execution outcomes.
+
+    INPUT (execution_result):
+    {
+        "name": str,
+        "mutation": dict | None,
+        "response": {
+            "status_code": int,
+            "body": dict | str
+        }
+    }
+
+    OUTPUT:
+    {
+        "type": str,
+        "confidence": float,
+        "explanation": str
+    }
+    """
+
+    def reason(self, execution_result: dict) -> dict:
+        test_name = execution_result.get("name")
+        mutation = execution_result.get("mutation")
+        response = execution_result.get("response") or {}
+
+        status_code = response.get("status_code")
+        response_body = response.get("body")
+
+        # =========================================================
+        # 1️⃣ HARD SUCCESS RULE — HAPPY PATH
+        # =========================================================
+        if (
+                test_name == "happy_path"
+                and mutation is None
+                and isinstance(status_code, int)
+                and 200 <= status_code < 300
+        ):
+            return {
+                "type": "success",
+                "confidence": 1.0,
+                "explanation": "Happy path executed successfully (2xx response)"
+            }
+
+        # =========================================================
+        # 2️⃣ NO RESPONSE / TRANSPORT FAILURE
+        # =========================================================
+        if status_code is None:
+            return {
+                "type": "unknown",
+                "confidence": 0.3,
+                "explanation": "No HTTP response received from server"
+            }
+
+        # =========================================================
+        # 3️⃣ HTTP-LEVEL HARD RULES (NO AI)
+        # =========================================================
+        if status_code == 405:
+            return {
+                "type": "method_not_allowed",
+                "confidence": 1.0,
+                "explanation": "HTTP 405 Method Not Allowed"
+            }
+
+        if status_code in (401, 403):
+            return {
+                "type": "auth_issue",
+                "confidence": 1.0,
+                "explanation": "Authentication or authorization failure"
+            }
+
+        if status_code >= 500:
+            return {
+                "type": "infra",
+                "confidence": 1.0,
+                "explanation": "Server-side 5xx failure"
+            }
+
+        # =====================================================
+        # 4️⃣ MUTATION-AWARE SEMANTIC CLASSIFICATION
+        # =====================================================
+        if mutation:
+            strategy = mutation.get("strategy")
+
+            if status_code == 400 and strategy == "missing_param":
+                return {
+                    "type": "missing_param",
+                    "confidence": 0.9,
+                    "explanation": "400 response after required parameter removal"
+                }
+
+            if status_code == 400 and strategy == "null_param":
+                return {
+                    "type": "missing_param",
+                    "confidence": 0.9,
+                    "explanation": "400 response after nullifying parameter"
+                }
+
+            if status_code == 400 and strategy == "invalid_param":
+                return {
+                    "type": "invalid_param",
+                    "confidence": 0.9,
+                    "explanation": "400 response after invalid parameter mutation"
+                }
+
+            # ✅ FIX: security payload blocked → SAFE
+            if status_code >= 400 and status_code < 500 and strategy == "security":
+                return {
+                    "type": "security",
+                    "confidence": 1.0,
+                    "explanation": (
+                        "Security payload was rejected with client error "
+                        "(treated as safe input validation)"
+                    )
+                }
+
+            # 🚨 security payload accepted → RISK
+            if status_code >= 200 and status_code < 300 and strategy == "security":
+                return {
+                    "type": "security_risk",
+                    "confidence": 1.0,
+                    "explanation": (
+                        "Security payload was accepted (potential vulnerability)"
+                    )
+                }
+
+        # =========================================================
+        # 5️⃣ BUSINESS LOGIC / GENERIC SUCCESS
+        # =========================================================
+        if 200 <= status_code < 300:
+            return {
+                "type": "success",
+                "confidence": 0.8,
+                "explanation": "2xx response without mutation-induced failure"
+            }
+
+        # =========================================================
+        # 6️⃣ FALLBACK
+        # =========================================================
+        return {
+            "type": "unknown",
+            "confidence": 0.6,
+            "explanation": "No deterministic rule matched this response"
+        }

ai_testing_swarm/agents/release_gate_agent.py

@@ -0,0 +1,177 @@
+# class ReleaseGateAgent:
+#     """
+#     Release decision engine based on mutation testing semantics.
+#
+#     IMPORTANT:
+#     - Test FAIL does NOT mean system FAIL
+#     - Only unexpected behavior blocks release
+#     """
+#
+#     # ❌ These mean SYSTEM IS BROKEN
+#     BLOCKING_FAILURES = {
+#         "auth_issue",       # auth broken
+#         "infra",            # infra / network / 5xx
+#         "security_risk",    # malicious payload succeeded (2xx/3xx)
+#         "server_error",
+#     }
+#
+#     # ⚠️ Ambiguous behavior (release with caution)
+#     RISKY_FAILURES = {
+#         "unknown",
+#     }
+#
+#     # ✅ EXPECTED & HEALTHY system behavior
+#     EXPECTED_FAILURES = {
+#         "success",
+#         "missing_param",
+#         "invalid_param",
+#         "security",
+#     }
+#
+#     def decide(self, results: list) -> str:
+#         happy_path_ok = False
+#         has_blocker = False
+#         has_risk = False
+#
+#         for r in results:
+#             test_name = r.get("test_name")
+#             failure_type = r.get("failure_type")
+#             status_code = r.get("response", {}).get("status_code")
+#
+#             # -------------------------------
+#             # Happy path MUST succeed
+#             # -------------------------------
+#             if test_name == "happy_path":
+#                 if failure_type == "success" and status_code and status_code < 400:
+#                     happy_path_ok = True
+#                 else:
+#                     return "REJECT_RELEASE"
+#
+#             # -------------------------------
+#             # Blocking issues
+#             # -------------------------------
+#             if failure_type in self.BLOCKING_FAILURES:
+#                 has_blocker = True
+#
+#             # -------------------------------
+#             # Risky but not blocking
+#             # -------------------------------
+#             elif failure_type in self.RISKY_FAILURES:
+#                 has_risk = True
+#
+#             # EXPECTED_FAILURES are intentionally ignored
+#
+#         # -------------------------------
+#         # Final decision
+#         # -------------------------------
+#         if has_blocker:
+#             return "REJECT_RELEASE"
+#
+#         if has_risk:
+#             return "APPROVE_RELEASE_WITH_RISKS"
+#
+#         return "APPROVE_RELEASE"
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ReleaseGateAgent:
+    """
+    Release decision engine based on mutation testing semantics.
+
+    IMPORTANT:
+    - Test FAIL does NOT mean system FAIL
+    - Only unexpected behavior blocks release
+    """
+
+    # ❌ These mean SYSTEM IS BROKEN
+    BLOCKING_FAILURES = {
+        "auth_issue",       # auth broken
+        "infra",            # infra / network / 5xx
+        "security_risk",    # malicious payload succeeded (2xx/3xx)
+        "server_error",
+        "method_not_allowed",
+    }
+
+    # ⚠️ Ambiguous behavior (release with caution)
+    RISKY_FAILURES = {
+        "unknown",
+    }
+
+    # ✅ EXPECTED & HEALTHY system behavior
+    EXPECTED_FAILURES = {
+        "success",
+        "missing_param",
+        "invalid_param",
+        "security",         # 🔥 IMPORTANT: security blocked = SAFE
+    }
+
+    def decide(self, results: list) -> str:
+        happy_path_ok = False
+        has_blocker = False
+        has_risk = False
+
+        for r in results:
+            # ✅ FIX 1: correct key
+            test_name = r.get("name") or r.get("test_name")
+            failure_type = r.get("failure_type")
+            status_code = r.get("response", {}).get("status_code")
+
+            logger.info(
+                "🔍 Evaluating test=%s | failure_type=%s | status_code=%s",
+                test_name,
+                failure_type,
+                status_code,
+            )
+
+            # -------------------------------
+            # Happy path MUST succeed
+            # -------------------------------
+            if test_name == "happy_path":
+                if failure_type == "success" and status_code and status_code < 400:
+                    happy_path_ok = True
+                    logger.info("✅ Happy path passed")
+                else:
+                    logger.error(
+                        "❌ Happy path failed → failure_type=%s status_code=%s",
+                        failure_type,
+                        status_code,
+                    )
+                    return "REJECT_RELEASE"
+
+            # -------------------------------
+            # Blocking issues
+            # -------------------------------
+            if failure_type in self.BLOCKING_FAILURES:
+                logger.error(
+                    "🚫 BLOCKING FAILURE DETECTED → test=%s | failure_type=%s | status_code=%s",
+                    test_name,
+                    failure_type,
+                    status_code,
+                )
+                has_blocker = True
+
+            # -------------------------------
+            # Risky but not blocking
+            # -------------------------------
+            elif failure_type in self.RISKY_FAILURES:
+                logger.warning(
+                    "⚠️ Risky behavior detected → test=%s | failure_type=%s",
+                    test_name,
+                    failure_type,
+                )
+                has_risk = True
+
+        # -------------------------------
+        # Final decision
+        # -------------------------------
+        if not happy_path_ok:
+            return "REJECT_RELEASE"
+
+        if has_blocker:
+            return "REJECT_RELEASE"
+
+        if has_risk:
+            return "APPROVE_RELEASE_WITH_RISKS"
+
+        return "APPROVE_RELEASE"

ai_testing_swarm/agents/test_planner_agent.py

@@ -0,0 +1,111 @@
+class TestPlannerAgent:
+    """
+    Generic test planner.
+    - Always includes happy path
+    - GET → query param mutations
+    - POST → body mutations
+    """
+
+    def plan(self, request: dict):
+        method = request["method"].upper()
+        params = request.get("params", {}) or {}
+        body = request.get("body", {}) or {}
+
+        tests = []
+
+        # ✅ POSITIVE CASE (ALWAYS)
+        tests.append({
+            "name": "happy_path",
+            "mutation": None,
+        })
+
+        # ---------------- GET QUERY PARAM MUTATIONS ----------------
+        if method == "GET" and params:
+            for key, value in params.items():
+                tests.extend([
+                    {
+                        "name": f"missing_param_{key}",
+                        "mutation": {
+                            "target": "query",
+                            "path": [key],
+                            "operation": "REMOVE",
+                            "original_value": value,
+                            "new_value": None,
+                            "strategy": "missing_param",
+                        },
+                    },
+                    {
+                        "name": f"empty_param_{key}",
+                        "mutation": {
+                            "target": "query",
+                            "path": [key],
+                            "operation": "REPLACE",
+                            "original_value": value,
+                            "new_value": "",
+                            "strategy": "invalid_param",
+                        },
+                    },
+                    {
+                        "name": f"invalid_param_{key}",
+                        "mutation": {
+                            "target": "query",
+                            "path": [key],
+                            "operation": "REPLACE",
+                            "original_value": value,
+                            "new_value": "INVALID",
+                            "strategy": "invalid_param",
+                        },
+                    },
+                    {
+                        "name": f"security_{key}",
+                        "mutation": {
+                            "target": "query",
+                            "path": [key],
+                            "operation": "REPLACE",
+                            "original_value": value,
+                            "new_value": "' OR 1=1 --",
+                            "strategy": "security",
+                        },
+                    },
+                ])
+
+        # ---------------- BODY MUTATIONS ----------------
+        if method != "GET" and body:
+            for key, value in body.items():
+                tests.extend([
+                    {
+                        "name": f"missing_param_{key}",
+                        "mutation": {
+                            "target": "body",
+                            "path": [key],
+                            "operation": "REMOVE",
+                            "original_value": value,
+                            "new_value": None,
+                            "strategy": "missing_param",
+                        },
+                    },
+                    {
+                        "name": f"invalid_param_{key}",
+                        "mutation": {
+                            "target": "body",
+                            "path": [key],
+                            "operation": "REPLACE",
+                            "original_value": value,
+                            "new_value": "INVALID",
+                            "strategy": "invalid_param",
+                        },
+                    },
+                    {
+                        "name": f"security_{key}",
+                        "mutation": {
+                            "target": "body",
+                            "path": [key],
+                            "operation": "REPLACE",
+                            "original_value": value,
+                            "new_value": "' OR 1=1 --",
+                            "strategy": "security",
+                        },
+                    },
+                ])
+
+        return tests

ai_testing_swarm/agents/test_writer_agent.py

@@ -0,0 +1,22 @@
+import copy
+
+
+class TestWriterAgent:
+    def write(self, request, plan):
+        tests = []
+
+        for step in plan:
+            if step == "happy_path":
+                tests.append(("happy_path", request))
+            else:
+                for key in request["body"].keys():
+                    r = copy.deepcopy(request)
+                    if step == "missing_param":
+                        r["body"].pop(key, None)
+                    elif step == "null_param":
+                        r["body"][key] = None
+                    elif step == "wrong_type":
+                        r["body"][key] = "INVALID"
+                    tests.append((f"{step}_{key}", r))
+
+        return tests

ai_testing_swarm/agents/ui_agent.py

@@ -0,0 +1,24 @@
+class UIAgent:
+    def validate(self, api_response):
+        try:
+            from playwright.sync_api import sync_playwright
+        except ImportError:
+            return {"ui": "skipped"}
+
+        if "order_id" not in api_response:
+            return {"ui": "not_applicable"}
+
+        with sync_playwright() as p:
+            browser = p.chromium.launch(headless=True)
+            page = browser.new_page()
+
+            page.goto("https://your-ui.com/orders")
+            page.fill("#order-search", str(api_response["order_id"]))
+            page.click("#search")
+
+            page.wait_for_selector(".order-id", timeout=5000)
+            visible_id = page.inner_text(".order-id")
+
+            browser.close()
+
+        return {"ui": visible_id == str(api_response["order_id"])}

ai_testing_swarm/cli.py

@@ -0,0 +1,78 @@
+import argparse
+import json
+from ai_testing_swarm.orchestrator import SwarmOrchestrator
+from ai_testing_swarm.core.curl_parser import parse_curl
+
+
+def normalize_request(payload: dict) -> dict:
+    """
+    Normalize input into execution-ready request.
+
+    Supported formats:
+    1. { "curl": "curl ..." }
+    2. { "method": "...", "url": "...", "headers": {...}, "body": {...} }
+    """
+
+    # Case 1: raw curl input
+    if "curl" in payload:
+        return parse_curl(payload["curl"])
+
+    # Case 2: already normalized
+    required_keys = {"method", "url"}
+    if required_keys.issubset(payload.keys()):
+        return payload
+
+    raise ValueError(
+        "Invalid input format.\n"
+        "Expected either:\n"
+        "1) { \"curl\": \"curl ...\" }\n"
+        "2) { \"method\": \"POST\", \"url\": \"...\", \"headers\": {}, \"body\": {} }"
+    )
+
+
+def main():
+    parser = argparse.ArgumentParser(description="AI Testing Swarm CLI")
+    parser.add_argument(
+        "--input",
+        required=True,
+        help="Path to request.json"
+    )
+
+    args = parser.parse_args()
+
+    # ------------------------------------------------------------
+    # Load input JSON
+    # ------------------------------------------------------------
+    with open(args.input) as f:
+        payload = json.load(f)
+
+    # ------------------------------------------------------------
+    # 🔴 NORMALIZE INPUT (THIS FIXES YOUR ERROR)
+    # ------------------------------------------------------------
+    request = normalize_request(payload)
+
+    # ------------------------------------------------------------
+    # Run swarm
+    # ------------------------------------------------------------
+    decision, results = SwarmOrchestrator().run(request)
+
+    # ------------------------------------------------------------
+    # Console output
+    # ------------------------------------------------------------
+    print("\n=== RELEASE DECISION ===")
+    print(decision)
+
+    print("\n=== TEST RESULTS ===")
+    for r in results:
+        response = r.get("response", {})
+        status_code = response.get("status_code")
+
+        print(
+            f"{r.get('name'):25} "
+            f"{str(status_code):5} "
+            f"{r.get('reason')}"
+        )
+
+
+if __name__ == "__main__":
+    main()

ai_testing_swarm/core/api_client.py

@@ -0,0 +1,19 @@
+import requests
+
+
+def send_request(method, url, headers=None, body=None, allow_redirects=False):
+    response = requests.request(
+        method=method,
+        url=url,
+        headers=headers,
+        json=body,
+        timeout=10,
+        allow_redirects=allow_redirects
+    )
+
+    try:
+        response_json = response.json()
+    except Exception:
+        response_json = {}
+
+    return response, response_json

ai_testing_swarm/core/curl_parser.py

@@ -0,0 +1,65 @@
+import shlex
+import urllib.parse
+import json
+
+
+def parse_curl(curl_command: str) -> dict:
+    tokens = shlex.split(curl_command)
+
+    method = "GET"
+    url = ""
+    headers = {}
+    body = None
+
+    i = 0
+    while i < len(tokens):
+        token = tokens[i]
+
+        if token in ("-X", "--request"):
+            method = tokens[i + 1].upper()
+            i += 2
+            continue
+
+        if token.startswith("http"):
+            url = token
+            i += 1
+            continue
+
+        if token in ("-H", "--header"):
+            header = tokens[i + 1]
+            key, value = header.split(":", 1)
+            headers[key.strip().lower()] = value.strip()
+            i += 2
+            continue
+
+        if token in ("-d", "--data", "--data-raw"):
+            body = tokens[i + 1]
+            method = "POST"
+            i += 2
+            continue
+
+        i += 1
+
+    # -------------------- URL PARSING (CRITICAL) --------------------
+    parsed_url = urllib.parse.urlparse(url)
+
+    params = dict(urllib.parse.parse_qsl(parsed_url.query))
+
+    clean_url = urllib.parse.urlunparse(
+        parsed_url._replace(query="")
+    )
+
+    parsed_body = {}
+    if body:
+        try:
+            parsed_body = json.loads(body)
+        except Exception:
+            parsed_body = body
+
+    return {
+        "method": method,
+        "url": clean_url,
+        "headers": headers,
+        "params": params,      # 🔥 THIS UNBLOCKS ALL TESTS
+        "body": parsed_body or {},
+    }

ai_testing_swarm/orchestrator.py

@@ -0,0 +1,93 @@
+from ai_testing_swarm.agents.test_planner_agent import TestPlannerAgent
+from ai_testing_swarm.agents.execution_agent import ExecutionAgent
+from ai_testing_swarm.agents.llm_reasoning_agent import LLMReasoningAgent
+from ai_testing_swarm.agents.learning_agent import LearningAgent
+from ai_testing_swarm.agents.release_gate_agent import ReleaseGateAgent
+from ai_testing_swarm.reporting.report_writer import write_report
+
+import logging
+
+logger = logging.getLogger(__name__)
+EXPECTED_FAILURES = {
+    "success",
+    "missing_param",
+    "invalid_param",
+    "security",
+}
+
+class SwarmOrchestrator:
+    """
+    Central brain of the AI Testing Swarm.
+    """
+
+    def __init__(self):
+        self.planner = TestPlannerAgent()
+        self.executor = ExecutionAgent()
+        self.reasoner = LLMReasoningAgent()
+        self.learner = LearningAgent()
+        self.release_gate = ReleaseGateAgent()
+
+    def run(self, request: dict):
+        """
+        Runs the full AI testing swarm and returns:
+        - release decision
+        - full test results
+        """
+
+        # --------------------------------------------------------
+        # 1️⃣ PLAN TESTS
+        # --------------------------------------------------------
+        tests = self.planner.plan(request)
+        results = []
+
+        logger.info("🧠 Planned %d tests", len(tests))
+
+        # --------------------------------------------------------
+        # 2️⃣ EXECUTE + CLASSIFY
+        # --------------------------------------------------------
+        for test in tests:
+            test_name = test.get("name")
+
+            # Execute request with mutation (or baseline)
+            execution_result = self.executor.execute(request, test)
+
+            # 🔒 GUARANTEE name is always present
+            execution_result["name"] = test_name
+
+            # Classify result (LLM / rules)
+            classification = self.reasoner.reason(execution_result)
+
+            # Merge classification into execution result
+            execution_result.update({
+                "reason": classification.get("type"),
+                "confidence": classification.get("confidence", 1.0),
+                "failure_type": classification.get("type"),
+                "status": (
+                    "PASSED"
+                    # if classification.get("type") == "success"
+                    if classification["type"] in EXPECTED_FAILURES
+                    else "FAILED"
+                ),
+            })
+
+            results.append(execution_result)
+
+            # Optional learning step
+            try:
+                self.learner.learn(test_name, classification)
+            except Exception as e:
+                logger.warning("⚠️ Learning skipped for %s: %s", test_name, e)
+
+        # --------------------------------------------------------
+        # 3️⃣ WRITE JSON REPORT (ONCE, ONLY ONCE)
+        # --------------------------------------------------------
+        report_path = write_report(request, results)
+        logger.info("📄 Swarm JSON report written to: %s", report_path)
+        print(f"📄 Swarm JSON report written to: {report_path}")
+
+        # --------------------------------------------------------
+        # 4️⃣ RELEASE DECISION
+        # --------------------------------------------------------
+        decision = self.release_gate.decide(results)
+
+        return decision, results

ai_testing_swarm/reporting/report_writer.py

@@ -0,0 +1,89 @@
+import json
+import os
+import re
+from datetime import datetime
+from pathlib import Path
+from urllib.parse import urlparse
+
+
+# ============================================================
+# 🔍 FIND CALLER PROJECT ROOT (NOT PACKAGE ROOT)
+# ============================================================
+def find_execution_root() -> Path:
+    """
+    Resolve project root based on WHERE tests are executed from,
+    not where this package lives.
+    """
+    current = Path.cwd().resolve()
+
+    while current != current.parent:
+        if any(
+            (current / marker).exists()
+            for marker in (
+                "pyproject.toml",
+                "setup.py",
+                "requirements.txt",
+                ".git",
+            )
+        ):
+            return current
+        current = current.parent
+
+    # Fallback: use cwd directly
+    return Path.cwd().resolve()
+
+
+PROJECT_ROOT = find_execution_root()
+REPORTS_DIR = PROJECT_ROOT / "ai_swarm_reports"
+
+
+# ============================================================
+# 🧹 UTILS
+# ============================================================
+def extract_endpoint_name(method: str, url: str) -> str:
+    """
+    POST https://preprod-api.getepichome.in/api/validate-gst/
+    -> POST_validate-gst
+    """
+    parsed = urlparse(url)
+    parts = [p for p in parsed.path.split("/") if p]
+
+    endpoint = parts[-1] if parts else "root"
+    endpoint = re.sub(r"[^a-zA-Z0-9_-]", "-", endpoint)
+
+    return f"{method}_{endpoint}"
+
+
+# ============================================================
+# 📝 REPORT WRITER
+# ============================================================
+def write_report(request: dict, results: list) -> str:
+    REPORTS_DIR.mkdir(exist_ok=True)
+
+    method = request.get("method", "UNKNOWN")
+    url = request.get("url", "")
+
+    endpoint_name = extract_endpoint_name(method, url)
+    timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
+
+    # report_path = REPORTS_DIR / f"{timestamp}_{endpoint_name}.json"
+    # 🔥 PER-ENDPOINT FOLDER
+    endpoint_dir = REPORTS_DIR / endpoint_name
+    endpoint_dir.mkdir(parents=True, exist_ok=True)
+
+    # 🔥 FILE NAME FORMAT
+    report_path = endpoint_dir / f"{endpoint_name}_{timestamp}.json"
+
+    report = {
+        "endpoint": f"{method} {url}",
+        "run_time": timestamp,
+        "total_tests": len(results),
+        "results": results,
+    }
+
+    with open(report_path, "w") as f:
+        json.dump(report, f, indent=2)
+
+    print(f"📄 Swarm JSON report written to: {report_path}")
+
+    return str(report_path)

ai_testing_swarm-0.1.1.dist-info/METADATA

@@ -0,0 +1,55 @@
+Metadata-Version: 2.4
+Name: ai-testing-swarm
+Version: 0.1.1
+Summary: AI-powered testing swarm
+Author-email: Arif Shah <ashah7775@gmail.com>
+License: MIT
+Requires-Python: >=3.9
+Description-Content-Type: text/markdown
+
+# AI Testing Swarm
+
+Autonomous AI-powered API & UI testing platform.
+
+## Run locally
+pip install -e .
+export OPENAI_API_KEY=your_key
+ai-test --input input/request.json
+
+## Pytest + Allure
+pytest --alluredir=allure-results
+allure serve allure-results
+
+
+ai-testing-swarm/
+│
+├── ai_testing_swarm/
+│   ├── __init__.py
+│   │
+│   ├── core/
+│   │   ├── curl_parser.py
+│   │   ├── api_client.py
+│   │
+│   ├── agents/
+│   │   ├── test_planner_agent.py
+│   │   ├── test_writer_agent.py
+│   │   ├── execution_agent.py
+│   │   ├── llm_reasoning_agent.py
+│   │   ├── learning_agent.py
+│   │   ├── release_gate_agent.py
+│   │   ├── ui_agent.py              👈 Playwright auto-plug
+│   │
+│   ├── orchestrator.py
+│
+│   └── cli.py                       👈 ai-test command
+│
+├── tests/
+│   ├── test_swarm_api.py            👈 pytest + allure
+│
+├── memory/
+│   └── failure_memory.json
+│
+├── pyproject.toml                   👈 packaging
+├── README.md
+└── input/
+    └── request.json

ai_testing_swarm-0.1.1.dist-info/RECORD

@@ -0,0 +1,21 @@
+ai_testing_swarm/__init__.py,sha256=kUR5RAFc7HCeiqdlX36dZOHkUI5wI6V_43RpEcD8b-0,22
+ai_testing_swarm/cli.py,sha256=Ug_8F4LCfj0qqXIzqjzwIi2lEzW41VS2SviB5z7Rb0E,2269
+ai_testing_swarm/orchestrator.py,sha256=96WqcLSvFnMUQ8O4Rxt4FaOBgf6pJBwMzgvJAxg_2BA,3381
+ai_testing_swarm/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_testing_swarm/agents/execution_agent.py,sha256=BT0wqPKagF54Pd-ORHei3wb3_CAZSpoas77O40qDrJA,1885
+ai_testing_swarm/agents/learning_agent.py,sha256=Py9uRdWlTKEHwMINyH4lJ0TNO4JP_w6k7F7IRLmb16A,689
+ai_testing_swarm/agents/llm_reasoning_agent.py,sha256=ESuli7edRW73RVewQBriSFCLsp_I476xdZA6hE2QqH4,5538
+ai_testing_swarm/agents/release_gate_agent.py,sha256=SSSuRYWtYs06VYkovyiMp3W3wNraAHY3840xUTU5ums,5605
+ai_testing_swarm/agents/test_planner_agent.py,sha256=3Wr57Gdrw8unyOjLSIowzZtyzhzpsHBuS71E53U56QQ,4167
+ai_testing_swarm/agents/test_writer_agent.py,sha256=tOCeUv01cl3t4vD8N8oXqVpxUFSE42agky5R9Dn2WVE,691
+ai_testing_swarm/agents/ui_agent.py,sha256=sNCTFbDIxkU8woKGoCHlUi83IRJCJrbxvkTYcSrB0EY,781
+ai_testing_swarm/core/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_testing_swarm/core/api_client.py,sha256=ENAL5W7Rg2PsggjvgEE301a4PXuBKpgU-5O107gGeQQ,415
+ai_testing_swarm/core/curl_parser.py,sha256=0dPEhRGqn-4u00t-bp7kW9Ii7GSiO0wteB4kDhRKUBQ,1483
+ai_testing_swarm/reporting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
+ai_testing_swarm/reporting/report_writer.py,sha256=drPRdxIgkXCcZifCAM3Y1FhR2ZE2ap0OnSQQlZQRiU4,2547
+ai_testing_swarm-0.1.1.dist-info/METADATA,sha256=00ctM45ApkGBaJbCxVZzCBAaXenWHYgwkgH14l5-lsI,1399
+ai_testing_swarm-0.1.1.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ai_testing_swarm-0.1.1.dist-info/entry_points.txt,sha256=vbW-IBcVcls5I-NA3xFUZxH4Ktevt7lA4w9P4Me0yXo,54
+ai_testing_swarm-0.1.1.dist-info/top_level.txt,sha256=OSqbej3vG04SKqgEcgzDTMn8QzpVsxwOzpSG7quhWJw,17
+ai_testing_swarm-0.1.1.dist-info/RECORD,,

ai_testing_swarm-0.1.1.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (80.10.2)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

ai_testing_swarm-0.1.1.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+ai-test = ai_testing_swarm.cli:main

ai_testing_swarm-0.1.1.dist-info/top_level.txt

@@ -0,0 +1 @@
+ai_testing_swarm