ai-testing-swarm 0.1.15__py3-none-any.whl → 0.1.17__py3-none-any.whl

ai_testing_swarm/__init__.py

@@ -1 +1 @@
-__version__ = "0.1.15"
+__version__ = "0.1.17"

ai_testing_swarm/agents/test_planner_agent.py

@@ -363,7 +363,58 @@ class TestPlannerAgent:
             for key, value in body.items():
                 add_field_mutations("body", key, value)
 
-        # 6) Optional OpenAI augmentation (best-effort)
+        # 6) Optional OpenAPI schema-based request-body fuzzing (best-effort)
+        try:
+            from ai_testing_swarm.core.config import (
+                AI_SWARM_OPENAPI_FUZZ,
+                AI_SWARM_OPENAPI_FUZZ_MAX_DEPTH,
+                AI_SWARM_OPENAPI_FUZZ_MAX_INVALID,
+                AI_SWARM_OPENAPI_FUZZ_MAX_VALID,
+            )
+
+            if AI_SWARM_OPENAPI_FUZZ and isinstance(request.get("_openapi"), dict):
+                ctx = request.get("_openapi") or {}
+                spec = ctx.get("spec")
+                path0 = ctx.get("path")
+                method0 = ctx.get("method")
+
+                if isinstance(spec, dict) and isinstance(path0, str) and isinstance(method0, str):
+                    from ai_testing_swarm.core.openapi_fuzzer import generate_request_body_fuzz_cases
+
+                    fuzz_cases = generate_request_body_fuzz_cases(
+                        spec=spec,
+                        path=path0,
+                        method=method0,
+                        max_valid=AI_SWARM_OPENAPI_FUZZ_MAX_VALID,
+                        max_invalid=AI_SWARM_OPENAPI_FUZZ_MAX_INVALID,
+                        max_depth=AI_SWARM_OPENAPI_FUZZ_MAX_DEPTH,
+                    )
+
+                    existing = {t["name"] for t in tests}
+                    for fc in fuzz_cases:
+                        name = fc.name
+                        if name in existing:
+                            continue
+                        tests.append(
+                            {
+                                "name": name,
+                                "mutation": {
+                                    "target": "body_whole",
+                                    "path": [],
+                                    "operation": "REPLACE",
+                                    "original_value": body,
+                                    "new_value": fc.body,
+                                    "strategy": "openapi_fuzz_valid" if fc.is_valid else "openapi_fuzz_invalid",
+                                    "openapi": {"is_valid": fc.is_valid, "details": fc.details},
+                                },
+                            }
+                        )
+                        existing.add(name)
+        except Exception:
+            # Never fail planning due to fuzzing issues
+            pass
+
+        # 7) Optional OpenAI augmentation (best-effort)
         try:
             from ai_testing_swarm.core.config import (
                 AI_SWARM_MAX_AI_TESTS,

ai_testing_swarm/cli.py

@@ -107,6 +107,54 @@ def main():
         help="Report format to write (default: json)",
     )
 
+    # OpenAPI schema-based request-body fuzzing
+    parser.add_argument(
+        "--openapi-fuzz",
+        dest="openapi_fuzz",
+        action="store_true",
+        default=True,
+        help="Enable OpenAPI schema-based request-body fuzzing when OpenAPI context is present (default: on)",
+    )
+    parser.add_argument(
+        "--no-openapi-fuzz",
+        dest="openapi_fuzz",
+        action="store_false",
+        help="Disable OpenAPI schema-based request-body fuzzing",
+    )
+    parser.add_argument(
+        "--openapi-fuzz-max-valid",
+        type=int,
+        default=8,
+        help="Max schema-valid OpenAPI fuzz cases to add (default: 8)",
+    )
+    parser.add_argument(
+        "--openapi-fuzz-max-invalid",
+        type=int,
+        default=8,
+        help="Max schema-invalid OpenAPI fuzz cases to add (default: 8)",
+    )
+    parser.add_argument(
+        "--openapi-fuzz-max-depth",
+        type=int,
+        default=6,
+        help="Max recursion depth for OpenAPI schema instance generation (default: 6)",
+    )
+
+    parser.add_argument(
+        "--fail-on-regression",
+        action="store_true",
+        help="Exit non-zero if the run regresses vs the previous JSON report for this endpoint",
+    )
+
+    parser.add_argument(
+        "--auth-matrix",
+        default="",
+        help=(
+            "Optional path to auth_matrix.yaml/json to run the same endpoint under multiple auth headers. "
+            "Each case is reported separately via a run label suffix."
+        ),
+    )
+
     # Batch1: risk gate thresholds (backward compatible defaults)
     parser.add_argument(
         "--gate-warn",
@@ -137,33 +185,89 @@ def main():
     # ------------------------------------------------------------
     # Run swarm
     # ------------------------------------------------------------
+    import os
+
     if args.public_only:
-        import os
         os.environ["AI_SWARM_PUBLIC_ONLY"] = "1"
 
-    decision, results = SwarmOrchestrator().run(
-        request,
-        report_format=args.report_format,
-        gate_warn=args.gate_warn,
-        gate_block=args.gate_block,
-    )
+    # CLI flags -> env toggles used by core.config
+    os.environ["AI_SWARM_OPENAPI_FUZZ"] = "1" if args.openapi_fuzz else "0"
+    os.environ["AI_SWARM_OPENAPI_FUZZ_MAX_VALID"] = str(int(args.openapi_fuzz_max_valid))
+    os.environ["AI_SWARM_OPENAPI_FUZZ_MAX_INVALID"] = str(int(args.openapi_fuzz_max_invalid))
+    os.environ["AI_SWARM_OPENAPI_FUZZ_MAX_DEPTH"] = str(int(args.openapi_fuzz_max_depth))
 
-    # ------------------------------------------------------------
-    # 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')}"
+    orch = SwarmOrchestrator()
+
+    def _print_console(decision, results, *, label: str = ""):
+        if label:
+            print(f"\n=== AUTH CASE: {label} ===")
+        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} {str(status_code):5} {r.get('reason')}")
+
+    def _maybe_fail_on_regression(report_path: str):
+        try:
+            with open(report_path, "r", encoding="utf-8") as f:
+                report = json.load(f)
+        except Exception:
+            return
+
+        trend = report.get("trend") or {}
+        regression_count = trend.get("regression_count")
+        try:
+            reg_i = int(regression_count or 0)
+        except Exception:
+            reg_i = 0
+
+        if reg_i > 0:
+            print(f"\n❌ Regression gate failed: regressions={reg_i} (see trend in report)")
+            raise SystemExit(2)
+
+    if args.auth_matrix:
+        from ai_testing_swarm.core.auth_matrix import load_auth_matrix, merge_auth_headers
+
+        cases = load_auth_matrix(args.auth_matrix)
+        for c in cases:
+            req2 = merge_auth_headers(request, c)
+            report_format = args.report_format
+            if args.fail_on_regression and report_format != "json":
+                # regression gate needs a machine-readable report
+                report_format = "json"
+
+            decision, results, report_path = orch.run(
+                req2,
+                report_format=report_format,
+                gate_warn=args.gate_warn,
+                gate_block=args.gate_block,
+                run_label=f"auth-{c.name}",
+                fail_on_regression=args.fail_on_regression,
+                return_report_path=True,
+            )
+            _print_console(decision, results, label=c.name)
+
+            if args.fail_on_regression:
+                _maybe_fail_on_regression(report_path)
+    else:
+        report_format = args.report_format
+        if args.fail_on_regression and report_format != "json":
+            report_format = "json"
+
+        decision, results, report_path = orch.run(
+            request,
+            report_format=report_format,
+            gate_warn=args.gate_warn,
+            gate_block=args.gate_block,
+            fail_on_regression=args.fail_on_regression,
+            return_report_path=True,
         )
+        _print_console(decision, results)
+
+        if args.fail_on_regression:
+            _maybe_fail_on_regression(report_path)
 
 
 if __name__ == "__main__":

ai_testing_swarm/core/auth_matrix.py

@@ -0,0 +1,93 @@
+from __future__ import annotations
+
+import json
+from dataclasses import dataclass
+from pathlib import Path
+
+import yaml
+
+
+@dataclass(frozen=True)
+class AuthCase:
+    name: str
+    headers: dict[str, str]
+
+
+def _sanitize_case_name(name: str) -> str:
+    name = str(name or "").strip()
+    if not name:
+        return "case"
+    # Keep it filesystem-friendly.
+    out = []
+    for ch in name:
+        if ch.isalnum() or ch in ("-", "_", "."):
+            out.append(ch)
+        else:
+            out.append("-")
+    return "".join(out).strip("-") or "case"
+
+
+def load_auth_matrix(path: str | Path) -> list[AuthCase]:
+    """Load an auth matrix config (yaml/json).
+
+    Schema:
+      {
+        "cases": [
+          {"name": "user", "headers": {"Authorization": "Bearer ..."}},
+          {"name": "admin", "headers": {"Authorization": "Bearer ..."}}
+        ]
+      }
+
+    Notes:
+      - This is intentionally minimal and explicit.
+      - Headers are merged into the base request headers (case wins).
+    """
+
+    p = Path(path)
+    raw = p.read_text(encoding="utf-8")
+    if p.suffix.lower() in {".yaml", ".yml"}:
+        data = yaml.safe_load(raw) or {}
+    else:
+        data = json.loads(raw)
+
+    cases = data.get("cases") if isinstance(data, dict) else None
+    if not isinstance(cases, list) or not cases:
+        raise ValueError("auth matrix must contain a non-empty 'cases' list")
+
+    out: list[AuthCase] = []
+    for i, c in enumerate(cases):
+        if not isinstance(c, dict):
+            raise ValueError(f"auth case #{i} must be an object")
+        name = _sanitize_case_name(c.get("name") or f"case{i+1}")
+        headers = c.get("headers") or {}
+        if not isinstance(headers, dict):
+            raise ValueError(f"auth case '{name}' headers must be an object")
+        # stringify values (avoid accidental ints)
+        headers2 = {str(k): str(v) for k, v in headers.items() if v is not None}
+        out.append(AuthCase(name=name, headers=headers2))
+
+    # Ensure unique names
+    seen: set[str] = set()
+    uniq: list[AuthCase] = []
+    for c in out:
+        nm = c.name
+        if nm not in seen:
+            uniq.append(c)
+            seen.add(nm)
+        else:
+            j = 2
+            while f"{nm}-{j}" in seen:
+                j += 1
+            new = f"{nm}-{j}"
+            uniq.append(AuthCase(name=new, headers=c.headers))
+            seen.add(new)
+
+    return uniq
+
+
+def merge_auth_headers(request: dict, auth_case: AuthCase) -> dict:
+    req = dict(request)
+    base_headers = dict(req.get("headers") or {})
+    base_headers.update(auth_case.headers or {})
+    req["headers"] = base_headers
+    return req

ai_testing_swarm/core/config.py

@@ -20,3 +20,9 @@ AI_SWARM_USE_OPENAI = os.getenv("AI_SWARM_USE_OPENAI", "0").lower() in {"1", "tr
 AI_SWARM_OPENAI_MODEL = os.getenv("AI_SWARM_OPENAI_MODEL", "gpt-4.1-mini")
 AI_SWARM_MAX_AI_TESTS = env_int("AI_SWARM_MAX_AI_TESTS", 20)
 AI_SWARM_AI_SUMMARY = os.getenv("AI_SWARM_AI_SUMMARY", "0").lower() in {"1", "true", "yes"}
+
+# OpenAPI schema-based request-body fuzzing (on by default when OpenAPI context exists)
+AI_SWARM_OPENAPI_FUZZ = os.getenv("AI_SWARM_OPENAPI_FUZZ", "1").lower() in {"1", "true", "yes"}
+AI_SWARM_OPENAPI_FUZZ_MAX_VALID = env_int("AI_SWARM_OPENAPI_FUZZ_MAX_VALID", 8)
+AI_SWARM_OPENAPI_FUZZ_MAX_INVALID = env_int("AI_SWARM_OPENAPI_FUZZ_MAX_INVALID", 8)
+AI_SWARM_OPENAPI_FUZZ_MAX_DEPTH = env_int("AI_SWARM_OPENAPI_FUZZ_MAX_DEPTH", 6)

ai_testing_swarm/core/openapi_fuzzer.py

@@ -0,0 +1,396 @@
+from __future__ import annotations
+
+"""OpenAPI request-body schema based fuzzing.
+
+This module is intentionally lightweight (no hypothesis/faker deps).
+It generates:
+  - schema-valid "edge" payloads (still validate)
+  - schema-invalid payloads (should violate validation)
+
+Used only when an OpenAPI spec is attached to the request.
+"""
+
+from dataclasses import dataclass
+from typing import Any
+
+
+@dataclass(frozen=True)
+class FuzzCase:
+    name: str
+    body: Any
+    is_valid: bool
+    details: dict | None = None
+
+
+def _get_operation(spec: dict, *, path: str, method: str) -> dict | None:
+    paths = spec.get("paths") or {}
+    op = (paths.get(path) or {}).get(str(method).lower())
+    return op if isinstance(op, dict) else None
+
+
+def get_request_body_schema(*, spec: dict, path: str, method: str) -> dict | None:
+    op = _get_operation(spec, path=path, method=method)
+    if not op:
+        return None
+
+    rb = op.get("requestBody")
+    if not isinstance(rb, dict):
+        return None
+
+    content = rb.get("content") or {}
+    if not isinstance(content, dict):
+        return None
+
+    # Prefer json
+    app_json = content.get("application/json") or content.get("application/*+json")
+    if not isinstance(app_json, dict):
+        return None
+
+    schema = app_json.get("schema")
+    if isinstance(schema, dict):
+        return schema
+    return None
+
+
+# ----------------------------
+# Minimal schema resolution
+# ----------------------------
+
+def _resolve_ref(schema: dict, *, resolver) -> dict:
+    if "$ref" not in schema:
+        return schema
+    ref = schema.get("$ref")
+    try:
+        # jsonschema.RefResolver API
+        with resolver.resolving(ref) as resolved:  # type: ignore[attr-defined]
+            if isinstance(resolved, dict):
+                return resolved
+    except Exception:
+        return schema
+    return schema
+
+
+def _choose_subschema(schema: dict) -> dict:
+    """Handle oneOf/anyOf/allOf in a deterministic best-effort manner."""
+    for key in ("oneOf", "anyOf"):
+        v = schema.get(key)
+        if isinstance(v, list) and v and isinstance(v[0], dict):
+            return v[0]
+    all_of = schema.get("allOf")
+    if isinstance(all_of, list) and all_of:
+        merged: dict = {}
+        for s in all_of:
+            if isinstance(s, dict):
+                # naive merge
+                merged.update({k: v for k, v in s.items() if k not in {"allOf"}})
+        return merged or schema
+    return schema
+
+
+def _schema_type(schema: dict) -> str | None:
+    t = schema.get("type")
+    if isinstance(t, str):
+        return t
+    if isinstance(t, list) and t:
+        # choose first
+        if isinstance(t[0], str):
+            return t[0]
+    # Infer common
+    if "properties" in schema:
+        return "object"
+    if "items" in schema:
+        return "array"
+    return None
+
+
+def _string_example(schema: dict) -> str:
+    if "enum" in schema and isinstance(schema.get("enum"), list) and schema["enum"]:
+        return str(schema["enum"][0])
+    if "default" in schema:
+        return str(schema["default"])
+    if "example" in schema:
+        return str(schema["example"])
+
+    min_len = schema.get("minLength")
+    try:
+        min_len_i = int(min_len) if min_len is not None else 1
+    except Exception:
+        min_len_i = 1
+
+    fmt = str(schema.get("format") or "")
+    if fmt == "date-time":
+        base = "2020-01-01T00:00:00Z"
+    elif fmt == "date":
+        base = "2020-01-01"
+    elif fmt == "uuid":
+        base = "00000000-0000-0000-0000-000000000000"
+    elif fmt == "email":
+        base = "a@example.com"
+    else:
+        base = "x"
+
+    if len(base) >= min_len_i:
+        return base
+    return base + ("x" * (min_len_i - len(base)))
+
+
+def _number_example(schema: dict, *, is_int: bool) -> int | float:
+    for k in ("default", "example"):
+        if k in schema:
+            v = schema.get(k)
+            if isinstance(v, (int, float)):
+                return int(v) if is_int else float(v)
+
+    minimum = schema.get("minimum")
+    exclusive_minimum = schema.get("exclusiveMinimum")
+
+    if isinstance(exclusive_minimum, (int, float)):
+        x = exclusive_minimum + 1
+        return int(x) if is_int else float(x)
+
+    if isinstance(minimum, (int, float)):
+        return int(minimum) if is_int else float(minimum)
+
+    return 0
+
+
+def build_minimal_valid_instance(schema: dict, *, resolver=None, max_depth: int = 6):
+    if max_depth <= 0:
+        return None
+
+    if resolver and isinstance(schema, dict) and "$ref" in schema:
+        schema = _resolve_ref(schema, resolver=resolver)
+
+    if not isinstance(schema, dict):
+        return None
+
+    schema = _choose_subschema(schema)
+
+    if "const" in schema:
+        return schema["const"]
+
+    t = _schema_type(schema)
+
+    if t == "object":
+        props = schema.get("properties") or {}
+        req = schema.get("required") or []
+        out: dict[str, Any] = {}
+
+        if isinstance(req, list):
+            for k in req:
+                if k in props and isinstance(props.get(k), dict):
+                    out[str(k)] = build_minimal_valid_instance(props[k], resolver=resolver, max_depth=max_depth - 1)
+
+        # If nothing required, pick the first property to make something non-empty
+        if not out and isinstance(props, dict) and props:
+            first = next(iter(props.keys()))
+            if isinstance(props.get(first), dict):
+                out[str(first)] = build_minimal_valid_instance(props[first], resolver=resolver, max_depth=max_depth - 1)
+
+        return out
+
+    if t == "array":
+        items = schema.get("items")
+        if not isinstance(items, dict):
+            return []
+        min_items = schema.get("minItems")
+        try:
+            n = int(min_items) if min_items is not None else 1
+        except Exception:
+            n = 1
+        n = max(0, min(n, 3))
+        return [build_minimal_valid_instance(items, resolver=resolver, max_depth=max_depth - 1) for _ in range(n)]
+
+    if t == "string":
+        return _string_example(schema)
+
+    if t == "integer":
+        return int(_number_example(schema, is_int=True))
+
+    if t == "number":
+        return float(_number_example(schema, is_int=False))
+
+    if t == "boolean":
+        return True
+
+    if t == "null":
+        return None
+
+    # unknown schema, best effort
+    if "enum" in schema and isinstance(schema.get("enum"), list) and schema["enum"]:
+        return schema["enum"][0]
+
+    return None
+
+
+# ----------------------------
+# Case generation
+# ----------------------------
+
+def _validate(schema: dict, instance, *, spec: dict) -> bool:
+    try:
+        import jsonschema  # type: ignore
+
+        resolver = jsonschema.RefResolver.from_schema(spec)  # type: ignore[attr-defined]
+        cls = jsonschema.validators.validator_for(schema)  # type: ignore[attr-defined]
+        cls.check_schema(schema)
+        v = cls(schema, resolver=resolver)
+        v.validate(instance)
+        return True
+    except Exception:
+        return False
+
+
+def generate_request_body_fuzz_cases(
+    *,
+    spec: dict,
+    path: str,
+    method: str,
+    max_valid: int = 8,
+    max_invalid: int = 8,
+    max_depth: int = 6,
+) -> list[FuzzCase]:
+    """Generate fuzz cases for an operation requestBody schema.
+
+    Requires optional dependency `jsonschema` (installed via ai-testing-swarm[openapi]).
+    Returns [] if schema missing or jsonschema not available.
+    """
+
+    try:
+        import jsonschema  # type: ignore
+    except ImportError:
+        return []
+
+    schema = get_request_body_schema(spec=spec, path=path, method=method)
+    if not schema:
+        return []
+
+    resolver = jsonschema.RefResolver.from_schema(spec)  # type: ignore[attr-defined]
+
+    base = build_minimal_valid_instance(schema, resolver=resolver, max_depth=max_depth)
+    cases: list[FuzzCase] = []
+
+    # Always include a minimal valid payload
+    if _validate(schema, base, spec=spec):
+        cases.append(FuzzCase(name="openapi_valid_minimal", body=base, is_valid=True))
+
+    # Valid edge-ish variants
+    def add_valid(name: str, body, details: dict | None = None):
+        if len([c for c in cases if c.is_valid]) >= max_valid:
+            return
+        if _validate(schema, body, spec=spec):
+            cases.append(FuzzCase(name=name, body=body, is_valid=True, details=details))
+
+    def add_invalid(name: str, body, details: dict | None = None):
+        if len([c for c in cases if not c.is_valid]) >= max_invalid:
+            return
+        # Ensure invalid (best-effort)
+        if not _validate(schema, body, spec=spec):
+            cases.append(FuzzCase(name=name, body=body, is_valid=False, details=details))
+
+    # Only attempt structured mutations for object bodies
+    schema2 = _choose_subschema(_resolve_ref(schema, resolver=resolver) if isinstance(schema, dict) else {})
+    if _schema_type(schema2) == "object" and isinstance(base, dict):
+        props = schema2.get("properties") or {}
+        required = schema2.get("required") or []
+        additional = schema2.get("additionalProperties")
+
+        # Required field removal (invalid)
+        if isinstance(required, list) and required:
+            k = str(required[0])
+            if k in base:
+                b2 = dict(base)
+                b2.pop(k, None)
+                add_invalid("openapi_invalid_missing_required", b2, {"missing": k})
+
+        # Extra field when additionalProperties is false (invalid)
+        if additional is False:
+            b2 = dict(base)
+            b2["_unexpected"] = "x"
+            add_invalid("openapi_invalid_additional_property", b2)
+
+        # Per-property boundary tweaks
+        if isinstance(props, dict):
+            for pk, ps in list(props.items())[: max(1, (max_valid + max_invalid))]:
+                if not isinstance(ps, dict):
+                    continue
+                ps = _choose_subschema(_resolve_ref(ps, resolver=resolver))
+                t = _schema_type(ps)
+
+                if t == "string":
+                    min_len = ps.get("minLength")
+                    max_len = ps.get("maxLength")
+                    enum = ps.get("enum")
+
+                    if isinstance(enum, list) and enum:
+                        add_valid(f"openapi_valid_enum_{pk}", {**base, pk: enum[-1]})
+
+                    if isinstance(min_len, int) and min_len >= 0:
+                        add_valid(f"openapi_valid_minLength_{pk}", {**base, pk: "x" * min_len})
+                        if min_len > 0:
+                            add_invalid(f"openapi_invalid_below_minLength_{pk}", {**base, pk: ""})
+
+                    if isinstance(max_len, int) and max_len >= 0:
+                        add_valid(f"openapi_valid_maxLength_{pk}", {**base, pk: "x" * max_len})
+                        add_invalid(f"openapi_invalid_above_maxLength_{pk}", {**base, pk: "x" * (max_len + 1)})
+
+                    # wrong type
+                    add_invalid(f"openapi_invalid_type_{pk}", {**base, pk: 123})
+
+                elif t in {"integer", "number"}:
+                    minimum = ps.get("minimum")
+                    maximum = ps.get("maximum")
+                    if isinstance(minimum, (int, float)):
+                        add_valid(f"openapi_valid_min_{pk}", {**base, pk: minimum})
+                        add_invalid(f"openapi_invalid_below_min_{pk}", {**base, pk: minimum - 1})
+                    if isinstance(maximum, (int, float)):
+                        add_valid(f"openapi_valid_max_{pk}", {**base, pk: maximum})
+                        add_invalid(f"openapi_invalid_above_max_{pk}", {**base, pk: maximum + 1})
+                    add_invalid(f"openapi_invalid_type_{pk}", {**base, pk: "x"})
+
+                elif t == "boolean":
+                    add_invalid(f"openapi_invalid_type_{pk}", {**base, pk: "true"})
+
+                elif t == "array":
+                    items = ps.get("items") if isinstance(ps.get("items"), dict) else None
+                    min_items = ps.get("minItems")
+                    max_items = ps.get("maxItems")
+                    if items:
+                        item_ex = build_minimal_valid_instance(items, resolver=resolver, max_depth=max_depth - 1)
+                    else:
+                        item_ex = "x"
+
+                    if isinstance(min_items, int) and min_items > 0:
+                        add_valid(f"openapi_valid_minItems_{pk}", {**base, pk: [item_ex for _ in range(min_items)]})
+                        add_invalid(f"openapi_invalid_below_minItems_{pk}", {**base, pk: []})
+
+                    if isinstance(max_items, int) and max_items >= 0:
+                        add_valid(f"openapi_valid_maxItems_{pk}", {**base, pk: [item_ex for _ in range(max_items)]})
+                        add_invalid(
+                            f"openapi_invalid_above_maxItems_{pk}",
+                            {**base, pk: [item_ex for _ in range(max_items + 1)]},
+                        )
+
+                    add_invalid(f"openapi_invalid_type_{pk}", {**base, pk: "not-an-array"})
+
+        # Ensure we have at least one invalid case
+        add_invalid("openapi_invalid_body_null", None)
+
+    else:
+        # For non-object bodies, do a couple generic cases
+        add_invalid("openapi_invalid_body_null", None)
+        add_invalid("openapi_invalid_wrong_type", {"_": "x"} if not isinstance(base, dict) else "x")
+
+    # De-dupe by name
+    seen: set[str] = set()
+    out: list[FuzzCase] = []
+    for c in cases:
+        if c.name in seen:
+            continue
+        seen.add(c.name)
+        out.append(c)
+
+    # Cap total
+    valid = [c for c in out if c.is_valid][:max_valid]
+    invalid = [c for c in out if not c.is_valid][:max_invalid]
+    return valid + invalid

ai_testing_swarm/core/risk.py

@@ -67,15 +67,22 @@ def compute_test_risk_score(result: dict, *, sla_ms: int | None = None) -> int:
     Inputs expected (best-effort):
       - result['failure_type']
       - result['status']
+      - result['mutation']['strategy'] (optional)
       - result['response']['status_code']
       - result['response']['elapsed_ms']
       - result['response']['openapi_validation'] (list)
 
     Returns: int in range 0..100.
+
+    Batch2: strategy-aware weighting.
+    The same failure_type can be more/less severe depending on the test strategy.
     """
 
     ft = str(result.get("failure_type") or "unknown")
     status = str(result.get("status") or "")
+    mutation = result.get("mutation") or {}
+    strategy = str(mutation.get("strategy") or "").strip().lower()
+
     resp = result.get("response") or {}
     sc = resp.get("status_code")
 
@@ -90,6 +97,21 @@ def compute_test_risk_score(result: dict, *, sla_ms: int | None = None) -> int:
         # Unknown failure types are treated as high risk but not always a hard blocker.
         base = 60
 
+    # Strategy-aware overrides (only when the strategy is known).
+    # These are designed to stay deterministic and explainable.
+    if strategy == "security" and ft == "security_risk":
+        base = max(base, 100)
+    if strategy in {"missing_param", "null_param", "invalid_param"} and ft.endswith("_accepted"):
+        # Validation bypass signals.
+        base = max(base, 80)
+    if strategy == "headers" and ft == "headers_accepted":
+        base = max(base, 55)
+    if strategy == "method_misuse" and ft == "method_risk":
+        base = max(base, 85)
+    if strategy == "auth" and ft == "auth_issue":
+        # Often indicates environment/config drift rather than product risk.
+        base = min(base, 70)
+
     # Status-code adjustments (defense in depth)
     if isinstance(sc, int):
         if 500 <= sc:

ai_testing_swarm/orchestrator.py

@@ -53,12 +53,19 @@ class SwarmOrchestrator:
         report_format: str = "json",
         gate_warn: int = 30,
         gate_block: int = 80,
+        run_label: str | None = None,
+        fail_on_regression: bool = False,
+        return_report_path: bool = False,
     ):
-        """Runs the full AI testing swarm and returns (decision, results).
+        """Runs the full AI testing swarm.
 
         gate_warn/gate_block:
           Thresholds for PASS/WARN/BLOCK gate based on endpoint risk.
           (Kept optional for backward compatibility.)
+
+        Returns:
+          - default: (decision, results)
+          - if return_report_path=True: (decision, results, report_path)
         """
 
         # Safety hook (currently no-op; kept for backward compatibility)
@@ -145,6 +152,11 @@ class SwarmOrchestrator:
             "gate_thresholds": {"warn": thresholds.warn, "block": thresholds.block},
             "endpoint_risk_score": endpoint_risk_score,
         }
+        if run_label:
+            meta["run_label"] = str(run_label)
+
+        if fail_on_regression:
+            meta["fail_on_regression"] = True
 
         # Optional AI summary for humans (best-effort)
         try:
@@ -166,4 +178,6 @@ class SwarmOrchestrator:
         logger.info("📄 Swarm report written to: %s", report_path)
         print(f"📄 Swarm report written to: {report_path}")
 
+        if return_report_path:
+            return decision, results, report_path
         return decision, results

ai_testing_swarm/reporting/dashboard.py

@@ -26,6 +26,8 @@ class EndpointRow:
     decision: str
     report_relpath: str
     top_risks: list[dict]
+    risk_delta: int | None = None
+    regression_count: int = 0
 
 
 def _latest_json_report(endpoint_dir: Path) -> Path | None:
@@ -65,6 +67,19 @@ def write_dashboard_index(reports_dir: Path) -> str:
         if endpoint_risk is None:
             endpoint_risk = summary.get("endpoint_risk_score", 0)
 
+        trend = rpt.get("trend") or {}
+        risk_delta = trend.get("endpoint_risk_delta") if isinstance(trend, dict) else None
+        try:
+            risk_delta = int(risk_delta) if risk_delta is not None else None
+        except Exception:
+            risk_delta = None
+
+        regression_count = 0
+        try:
+            regression_count = int(trend.get("regression_count") or 0) if isinstance(trend, dict) else 0
+        except Exception:
+            regression_count = 0
+
         row = EndpointRow(
             endpoint_dir=child.name,
             endpoint=str(rpt.get("endpoint") or child.name),
@@ -74,11 +89,13 @@ def write_dashboard_index(reports_dir: Path) -> str:
             decision=str(meta.get("decision") or ""),
             report_relpath=str(child.name + "/" + latest.name),
             top_risks=list(summary.get("top_risks") or []),
+            risk_delta=risk_delta,
+            regression_count=regression_count,
         )
         rows.append(row)
 
-    # Sort by risk (desc) then recent
-    rows.sort(key=lambda r: (r.endpoint_risk_score, r.run_time), reverse=True)
+    # Batch2: surface regressions first, then risk (desc), then recency.
+    rows.sort(key=lambda r: (int(r.regression_count or 0), r.endpoint_risk_score, r.run_time), reverse=True)
 
     # Global top risks across endpoints
     global_risks = []
@@ -102,16 +119,24 @@ def write_dashboard_index(reports_dir: Path) -> str:
         cls = {"PASS": "pass", "WARN": "warn", "BLOCK": "block"}.get(gate, "")
         return f"<span class='gate {cls}'>{_html_escape(gate)}</span>"
 
+    def _delta_badge(d: int | None) -> str:
+        if d is None:
+            return ""
+        cls = "pos" if d > 0 else "neg" if d < 0 else "zero"
+        sign = "+" if d > 0 else ""
+        return f"<span class='delta {cls}'>{sign}{_html_escape(d)}</span>"
+
     endpoint_rows_html = "".join(
         "<tr>"
         f"<td>{badge(r.gate_status)}</td>"
-        f"<td><code>{_html_escape(r.endpoint_risk_score)}</code></td>"
+        f"<td><code>{_html_escape(r.endpoint_risk_score)}</code> {_delta_badge(r.risk_delta)}</td>"
+        f"<td><code>{_html_escape(r.regression_count)}</code></td>"
         f"<td><a href='{_html_escape(r.report_relpath)}'>{_html_escape(r.endpoint)}</a></td>"
         f"<td><code>{_html_escape(r.run_time)}</code></td>"
         f"<td><code>{_html_escape(r.decision)}</code></td>"
         "</tr>"
         for r in rows
-    ) or "<tr><td colspan='5'>(no JSON reports found)</td></tr>"
+    ) or "<tr><td colspan='6'>(no JSON reports found)</td></tr>"
 
     top_risks_html = "".join(
         "<tr>"
@@ -135,6 +160,10 @@ def write_dashboard_index(reports_dir: Path) -> str:
     .gate.warn{background:#fff7e6; border-color:#ffab00;}
     .gate.block{background:#ffebe6; border-color:#ff5630;}
     .muted{color:#555}
+    .delta{display:inline-block; margin-left:6px; padding:1px 8px; border-radius:999px; font-size:12px; border:1px solid #bbb;}
+    .delta.pos{background:#ffebe6; border-color:#ff5630;}
+    .delta.neg{background:#e6ffed; border-color:#36b37e;}
+    .delta.zero{background:#f1f2f4; border-color:#bbb;}
     """
 
     html = f"""<!doctype html>
@@ -153,7 +182,8 @@ def write_dashboard_index(reports_dir: Path) -> str:
   <thead>
     <tr>
       <th>Gate</th>
-      <th>Risk</th>
+      <th>Risk (Δ)</th>
+      <th>Regressions</th>
       <th>Endpoint</th>
       <th>Run time</th>
       <th>Decision</th>

ai_testing_swarm/reporting/report_writer.py

@@ -113,6 +113,26 @@ def _render_markdown(report: dict) -> str:
 
     lines.append("")
 
+    # Batch2: trend
+    trend = report.get("trend") or {}
+    if trend.get("has_previous"):
+        lines.append("## Trend vs previous run")
+        lines.append("")
+        lines.append(f"- **Endpoint risk delta:** `{trend.get('endpoint_risk_delta')}` (prev={trend.get('endpoint_risk_prev')})")
+        lines.append(f"- **Regressions:** `{trend.get('regression_count')}`")
+        regs = trend.get("regressions") or []
+        if regs:
+            lines.append("")
+            lines.append("### Regressed tests")
+            for x in regs[:10]:
+                lines.append(
+                    "- "
+                    f"`{_markdown_escape(x.get('name'))}`: "
+                    f"{_markdown_escape(x.get('prev_status'))}→{_markdown_escape(x.get('curr_status'))} "
+                    f"(risk {x.get('prev_risk_score')}→{x.get('curr_risk_score')})"
+                )
+        lines.append("")
+
     summary = report.get("summary") or {}
     counts_ft = summary.get("counts_by_failure_type") or {}
     counts_sc = summary.get("counts_by_status_code") or {}
@@ -174,6 +194,28 @@ def _render_html(report: dict) -> str:
     failed = [r for r in results if str(r.get("status")) == "FAILED"]
     top_risky = (risky + failed)[:10]
 
+    trend = report.get("trend") or {}
+    trend_html = ""
+    if trend.get("has_previous"):
+        regs = trend.get("regressions") or []
+        items = "".join(
+            "<li><code>{}</code>: {}→{} (risk {}→{})</li>".format(
+                _html_escape(x.get("name")),
+                _html_escape(x.get("prev_status")),
+                _html_escape(x.get("curr_status")),
+                _html_escape(x.get("prev_risk_score")),
+                _html_escape(x.get("curr_risk_score")),
+            )
+            for x in regs[:10]
+        ) or "<li>(none)</li>"
+        trend_html = (
+            "<h2>Trend vs previous run</h2>"
+            f"<div class='meta'><div><b>Endpoint risk delta:</b> <code>{_html_escape(trend.get('endpoint_risk_delta'))}</code> "
+            f"(prev <code>{_html_escape(trend.get('endpoint_risk_prev'))}</code>)</div>"
+            f"<div><b>Regressions:</b> <code>{_html_escape(trend.get('regression_count'))}</code></div></div>"
+            f"<ul>{items}</ul>"
+        )
+
     def _kv_list(d: dict) -> str:
         items = sorted((d or {}).items(), key=lambda kv: (-kv[1], kv[0]))
         return "".join(f"<li><b>{_html_escape(k)}</b>: {v}</li>" for k, v in items) or "<li>(none)</li>"
@@ -251,6 +293,8 @@ def _render_html(report: dict) -> str:
   <div><b>Endpoint risk:</b> <code>{_html_escape(meta.get('endpoint_risk_score'))}</code></div>
 </div>
 
+{trend_html}
+
 <h2>Summary</h2>
 <div class='grid'>
   <div><h3>Counts by failure type</h3><ul>{_kv_list(summary.get('counts_by_failure_type') or {})}</ul></div>
@@ -287,6 +331,15 @@ def write_report(
     url = request.get("url", "")
 
     endpoint_name = extract_endpoint_name(method, url)
+
+    # Batch2: optional run label (auth-matrix case, environment label, etc.)
+    # This keeps reports for the same endpoint separated but still comparable.
+    run_label = str((meta or {}).get("run_label") or "").strip()
+    if run_label:
+        safe = re.sub(r"[^a-zA-Z0-9_.-]", "-", run_label).strip("-")
+        if safe:
+            endpoint_name = f"{endpoint_name}__{safe}"
+
     timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
 
     endpoint_dir = REPORTS_DIR / endpoint_name
@@ -294,6 +347,18 @@ def write_report(
 
     safe_results = _redact_results(results)
 
+    # Batch2: load the previous JSON report for trend comparison (best-effort)
+    previous_report = None
+    try:
+        from ai_testing_swarm.reporting.trend import compute_trend
+
+        json_candidates = sorted(endpoint_dir.glob("*.json"), key=lambda p: p.stat().st_mtime, reverse=True)
+        prev_path = json_candidates[0] if json_candidates else None
+        if prev_path and prev_path.exists():
+            previous_report = json.loads(prev_path.read_text(encoding="utf-8"))
+    except Exception:
+        previous_report = None
+
     summary = {
         "counts_by_failure_type": {},
         "counts_by_status_code": {},
@@ -346,6 +411,14 @@ def write_report(
         "results": safe_results,
     }
 
+    # Batch2: attach trend comparison (previous vs current)
+    try:
+        from ai_testing_swarm.reporting.trend import compute_trend
+
+        report["trend"] = compute_trend(report, previous_report)
+    except Exception:
+        report["trend"] = {"has_previous": False, "regressions": [], "regression_count": 0}
+
     report_format = (report_format or "json").lower().strip()
     if report_format not in {"json", "md", "html"}:
         report_format = "json"

ai_testing_swarm/reporting/trend.py

@@ -0,0 +1,110 @@
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass(frozen=True)
+class Regression:
+    name: str
+    prev_status: str
+    curr_status: str
+    prev_risk_score: int
+    curr_risk_score: int
+
+
+def _status_rank(s: str) -> int:
+    s = (s or "").upper()
+    return {"PASSED": 0, "RISK": 1, "FAILED": 2}.get(s, 1)
+
+
+def compute_trend(current_report: dict, previous_report: dict | None) -> dict:
+    """Compute a best-effort trend comparison.
+
+    Trend is designed to be resilient to older report shapes.
+
+    Returns a dict that can be embedded into report['trend'].
+    """
+
+    if not previous_report:
+        return {
+            "has_previous": False,
+            "regressions": [],
+            "regression_count": 0,
+            "endpoint_risk_prev": None,
+            "endpoint_risk_delta": None,
+        }
+
+    cur_meta = current_report.get("meta") or {}
+    prev_meta = previous_report.get("meta") or {}
+
+    cur_risk = cur_meta.get("endpoint_risk_score")
+    if cur_risk is None:
+        cur_risk = (current_report.get("summary") or {}).get("endpoint_risk_score")
+
+    prev_risk = prev_meta.get("endpoint_risk_score")
+    if prev_risk is None:
+        prev_risk = (previous_report.get("summary") or {}).get("endpoint_risk_score")
+
+    try:
+        cur_risk_i = int(cur_risk or 0)
+    except Exception:
+        cur_risk_i = 0
+    try:
+        prev_risk_i = int(prev_risk or 0)
+    except Exception:
+        prev_risk_i = 0
+
+    cur_results = current_report.get("results") or []
+    prev_results = previous_report.get("results") or []
+
+    prev_by_name = {str(r.get("name")): r for r in prev_results if r.get("name") is not None}
+
+    regressions: list[Regression] = []
+    for r in cur_results:
+        name = r.get("name")
+        if name is None:
+            continue
+        name = str(name)
+        prev = prev_by_name.get(name)
+        if not prev:
+            continue
+
+        prev_status = str(prev.get("status") or "")
+        cur_status = str(r.get("status") or "")
+        prev_score = prev.get("risk_score")
+        cur_score = r.get("risk_score")
+        prev_score_i = int(prev_score) if isinstance(prev_score, int) else 0
+        cur_score_i = int(cur_score) if isinstance(cur_score, int) else 0
+
+        worsened_status = _status_rank(cur_status) > _status_rank(prev_status)
+        worsened_score = cur_score_i > prev_score_i
+
+        if worsened_status or worsened_score:
+            regressions.append(
+                Regression(
+                    name=name,
+                    prev_status=prev_status,
+                    curr_status=cur_status,
+                    prev_risk_score=prev_score_i,
+                    curr_risk_score=cur_score_i,
+                )
+            )
+
+    regressions.sort(key=lambda x: (x.curr_risk_score - x.prev_risk_score, _status_rank(x.curr_status)), reverse=True)
+
+    return {
+        "has_previous": True,
+        "endpoint_risk_prev": prev_risk_i,
+        "endpoint_risk_delta": cur_risk_i - prev_risk_i,
+        "regression_count": len(regressions),
+        "regressions": [
+            {
+                "name": x.name,
+                "prev_status": x.prev_status,
+                "curr_status": x.curr_status,
+                "prev_risk_score": x.prev_risk_score,
+                "curr_risk_score": x.curr_risk_score,
+            }
+            for x in regressions[:50]
+        ],
+    }

{ai_testing_swarm-0.1.15.dist-info → ai_testing_swarm-0.1.17.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: ai-testing-swarm
-Version: 0.1.15
+Version: 0.1.17
 Summary: AI-powered testing swarm
 Author-email: Arif Shah <ashah7775@gmail.com>
 License: MIT
@@ -10,6 +10,8 @@ Requires-Dist: requests>=2.28
 Requires-Dist: PyYAML>=6.0
 Provides-Extra: openapi
 Requires-Dist: jsonschema>=4.0; extra == "openapi"
+Provides-Extra: dev
+Requires-Dist: pytest>=8.0; extra == "dev"
 
 # AI Testing Swarm
 
@@ -70,7 +72,9 @@ A report is written under:
 - `./ai_swarm_reports/<METHOD>_<endpoint>/<METHOD>_<endpoint>_<timestamp>.<json|md|html>`
 
 Reports include:
-- per-test results
+- per-test results (including deterministic `risk_score` 0..100)
+- endpoint-level risk gate (`PASS`/`WARN`/`BLOCK`)
+- trend vs previous run for the same endpoint (risk delta + regressions)
 - summary counts by status code / failure type
 - optional AI summary (if enabled)
 
@@ -115,6 +119,10 @@ Reports include:
 - Base URL is read from `spec.servers[0].url`.
 - When using OpenAPI input, the swarm will also *optionally* validate response status codes against `operation.responses`.
 - If `jsonschema` is installed (via `ai-testing-swarm[openapi]`) and the response is JSON, response bodies are validated against the OpenAPI `application/json` schema.
+- If an OpenAPI requestBody schema exists for the operation, the planner can also generate **schema-based request-body fuzz cases**:
+  - schema-valid edge cases (boundary values that should still validate)
+  - schema-invalid variants (missing required fields, wrong types, out-of-range, etc.)
+  - Controlled via CLI flags like `--no-openapi-fuzz` / `--openapi-fuzz-max-*`.
   - Override with `AI_SWARM_OPENAPI_BASE_URL` if your spec doesn’t include servers.
 
 ---
@@ -140,6 +148,28 @@ Then generates broad coverage across:
 
 ---
 
+## Auth matrix runner (multiple tokens/headers)
+
+To run the *same* request under multiple auth contexts (e.g., user/admin tokens), create `auth_matrix.yaml`:
+
+```yaml
+cases:
+  - name: user
+    headers:
+      Authorization: "Bearer USER_TOKEN"
+  - name: admin
+    headers:
+      Authorization: "Bearer ADMIN_TOKEN"
+```
+
+Run:
+
+```bash
+ai-test --input request.json --auth-matrix auth_matrix.yaml
+```
+
+Each auth case is written as a separate report using a `run_label` suffix (e.g. `__auth-user`).
+
 ## Safety mode (recommended for CI/demos)
 
 Mutation testing can be noisy and may accidentally stress a real environment.
@@ -191,6 +221,21 @@ Reports include:
 - `summary.counts_by_failure_type`
 - `summary.counts_by_status_code`
 - `summary.slow_tests` (based on SLA)
+- `meta.endpoint_risk_score` + `meta.gate_status`
+- `trend.*` (previous comparison if a prior report exists)
+
+A static dashboard index is generated at:
+- `./ai_swarm_reports/index.html` (latest JSON report per endpoint, sorted by regressions/risk)
+
+### Regression gate (CI)
+
+To fail CI when the run regresses vs the previous JSON report for the same endpoint:
+
+```bash
+ai-test --input request.json --fail-on-regression
+```
+
+This checks `report.trend.regression_count` and exits with a non-zero code if regressions are detected.
 
 SLA threshold:
 - `AI_SWARM_SLA_MS` (default: `2000`)

{ai_testing_swarm-0.1.15.dist-info → ai_testing_swarm-0.1.17.dist-info}/RECORD

@@ -1,28 +1,31 @@
-ai_testing_swarm/__init__.py,sha256=qb0TalpSt1CbprnFyeLUKqgrqNtmnk9IoQQ7umAoXVY,23
-ai_testing_swarm/cli.py,sha256=IeCU0E1Ju8hfkHXT4ySI1KVSvKAlYK429Fa5atcAjdo,5626
-ai_testing_swarm/orchestrator.py,sha256=8uaUuyGy2lm3QzTNVl_8AeYtbyzrrxuykGQchRn1EEo,6295
+ai_testing_swarm/__init__.py,sha256=BzIjnki8Bz3evNWo6bjGxxpLhy_tN9MRYhtM0MnDiWs,23
+ai_testing_swarm/cli.py,sha256=_UzXKfMF02EqUI0-XnKHw2k-MqBa0jEEfottomeaXFs,9458
+ai_testing_swarm/orchestrator.py,sha256=jArGwLkfF0gVykVFDFX0EfeVBqb1SKv48cDsP1q_f38,6745
 ai_testing_swarm/agents/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
 ai_testing_swarm/agents/execution_agent.py,sha256=lkipsVOWe7agMt3kY9gDxjHfWujLtMh9DJCsAKhYzD8,8050
 ai_testing_swarm/agents/learning_agent.py,sha256=lHqikc8A8s2-Yln_qCm8hCxB9KTqVrTcNvFp20_QQU0,777
 ai_testing_swarm/agents/llm_reasoning_agent.py,sha256=nOA7Y8ixEh4sz67youSNPjFKipFSsfeup8XeSG4TvTg,8481
 ai_testing_swarm/agents/release_gate_agent.py,sha256=ontmkoWe86CmId2aLWVmzxUVw_-T-F5dCxt40o27oZ8,5888
-ai_testing_swarm/agents/test_planner_agent.py,sha256=mCCa67F2ilsPJG_msIwft4TLRySiKoklEhZyc17RFR0,13762
+ai_testing_swarm/agents/test_planner_agent.py,sha256=Ej0YFF-MIcUfuLQVzO0iTg4jnZtRycGkbTSlRADFmSc,16090
 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/config.py,sha256=loZcH45TlUseZMYZ9pkYpsK4AH1PaQ7PLv-AOZq_nQU,908
+ai_testing_swarm/core/auth_matrix.py,sha256=myCU6inO_Fnv5d4RWNGp8vy8SWySOCogpcrPUDzKuJE,2644
+ai_testing_swarm/core/config.py,sha256=4doRsvOhfGY_hlZcoIe_G55spWQc9-UNpcokisYcqjA,1337
 ai_testing_swarm/core/curl_parser.py,sha256=0dPEhRGqn-4u00t-bp7kW9Ii7GSiO0wteB4kDhRKUBQ,1483
 ai_testing_swarm/core/openai_client.py,sha256=gxbrZZZUh_jBcXfxtsBei2t72_xEQrKZ0Z10HjS62Ss,5668
+ai_testing_swarm/core/openapi_fuzzer.py,sha256=wIpL87J53EGYji_ArMB3_XZ1R3zhAuHEDvkQYQmA7pM,13630
 ai_testing_swarm/core/openapi_loader.py,sha256=lZ1Y7lyyEL4Y90pc-naZQbCyNGndr4GmmUAvR71bpos,3639
 ai_testing_swarm/core/openapi_validator.py,sha256=8oZNSCBSf6O6CyHZj9MB8Ojaqw54DzJqSm6pbF57HuE,5153
-ai_testing_swarm/core/risk.py,sha256=9FtBWwq3_a1xZd5r-F78g9G6WaxA76xJBMe4LR90A_4,3646
+ai_testing_swarm/core/risk.py,sha256=hT_odEOXWffGu6I8w7_5nK_iM4iu90mw4mQtsj_y6mc,4644
 ai_testing_swarm/core/safety.py,sha256=MvOMr7pKFAn0z37pBcE8X8dOqPK-juxhypCZQ4YcriI,825
 ai_testing_swarm/reporting/__init__.py,sha256=47DEQpj8HBSa-_TImW-5JCeuQeRkm5NMpJWZG3hSuFU,0
-ai_testing_swarm/reporting/dashboard.py,sha256=W53SRD6ttT7C3VCcsB9nkXOGWaoRwzOp-cZaj1NcRx8,5682
-ai_testing_swarm/reporting/report_writer.py,sha256=wLndx2VPPldGxbCuMyCaWd3VesVRLBPGQ8n9jyyTctI,12554
-ai_testing_swarm-0.1.15.dist-info/METADATA,sha256=hAwNBIjwMxfpDBXHuomFLBHNM0csFl9ELwaXgAZtuyk,5562
-ai_testing_swarm-0.1.15.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-ai_testing_swarm-0.1.15.dist-info/entry_points.txt,sha256=vbW-IBcVcls5I-NA3xFUZxH4Ktevt7lA4w9P4Me0yXo,54
-ai_testing_swarm-0.1.15.dist-info/top_level.txt,sha256=OSqbej3vG04SKqgEcgzDTMn8QzpVsxwOzpSG7quhWJw,17
-ai_testing_swarm-0.1.15.dist-info/RECORD,,
+ai_testing_swarm/reporting/dashboard.py,sha256=A-6XihDSY4s5VBjarNN6E-fBAMs_4JDaNV6YuXcVjwI,7067
+ai_testing_swarm/reporting/report_writer.py,sha256=JsP-MLEGxImbK32tT0Lr4a5VBK27a4Fw66lfB04AQU8,15717
+ai_testing_swarm/reporting/trend.py,sha256=YZhQA2SLLsJS2qwKUuRLoz1KdjS7LBYkTXhisVGEtx8,3386
+ai_testing_swarm-0.1.17.dist-info/METADATA,sha256=Kxnaj9rNX9IFyVt9-tIbkoaWUnprWdd7wROHEkAUSgw,7191
+ai_testing_swarm-0.1.17.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+ai_testing_swarm-0.1.17.dist-info/entry_points.txt,sha256=vbW-IBcVcls5I-NA3xFUZxH4Ktevt7lA4w9P4Me0yXo,54
+ai_testing_swarm-0.1.17.dist-info/top_level.txt,sha256=OSqbej3vG04SKqgEcgzDTMn8QzpVsxwOzpSG7quhWJw,17
+ai_testing_swarm-0.1.17.dist-info/RECORD,,