specforge-api 0.1.0__py3-none-any.whl

specforge/testing/invariants.py

@@ -0,0 +1,170 @@
+"""Test invariants, status evaluations, and result data structures."""
+
+from dataclasses import dataclass, field
+from enum import Enum
+from typing import Any
+
+
+class TestStatus(str, Enum):
+    PASS = "PASS"                  # Server cleanly rejected invalid input (400/422) or accepted valid input
+    WARN_LEAK = "WARN_LEAK"        # Server returned 200 OK for an invalid/boundary payload (Schema Leak)
+    CRASH_500 = "CRASH_500"        # Server threw an unhandled 500 error on client input (Critical Crash)
+    FAIL_STATUS = "FAIL_STATUS"    # Unexpected status code (e.g. 404 instead of 422)
+
+
+@dataclass
+class TestCase:
+    """Represents an executable boundary or negative test case against an API endpoint."""
+
+    id: str
+    endpoint: str
+    method: str
+    field_name: str
+    mutation_category: str
+    mutation_name: str
+    description: str
+    payload: Any
+    headers: dict[str, str] = field(default_factory=dict)
+    query_params: dict[str, Any] = field(default_factory=dict)
+    expected_status: int = 422
+    is_negative_test: bool = True
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert test case to dictionary for frontend execution or serialization."""
+        return {
+            "id": self.id,
+            "endpoint": self.endpoint,
+            "method": self.method,
+            "field_name": self.field_name,
+            "mutation_category": self.mutation_category,
+            "mutation_name": self.mutation_name,
+            "description": self.description,
+            "payload": self.payload,
+            "headers": self.headers,
+            "query_params": self.query_params,
+            "expected_status": self.expected_status,
+            "is_negative_test": self.is_negative_test,
+        }
+
+
+@dataclass
+class TestResult:
+    """Represents the execution outcome of a TestCase."""
+
+    test_case: TestCase
+    actual_status: int
+    latency_ms: float
+    response_body: str
+    status: TestStatus
+    message: str
+    curl_command: str = ""
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert result to dictionary for frontend inspection."""
+        return {
+            "test_case": self.test_case.to_dict(),
+            "actual_status": self.actual_status,
+            "latency_ms": self.latency_ms,
+            "response_body": self.response_body,
+            "status": self.status.value,
+            "message": self.message,
+            "curl_command": self.curl_command,
+        }
+
+
+def evaluate_test_result(
+    test_case: TestCase,
+    status_code: int,
+    response_body: str,
+    latency_ms: float,
+) -> TestResult:
+    """Evaluate HTTP execution against contract invariants."""
+    curl_cmd = build_curl_command(test_case)
+
+    # Invariant 1: An HTTP 500 on ANY input is an unhandled server crash bug
+    if status_code >= 500:
+        return TestResult(
+            test_case=test_case,
+            actual_status=status_code,
+            latency_ms=latency_ms,
+            response_body=response_body,
+            status=TestStatus.CRASH_500,
+            message=f"CRITICAL: Server crashed with {status_code} on {test_case.mutation_name}!",
+            curl_command=curl_cmd,
+        )
+
+    # Invariant 2: Negative test expects a rejection (400 or 422). If 200/201 was returned, it's a schema leak
+    if test_case.is_negative_test:
+        if 200 <= status_code < 300:
+            return TestResult(
+                test_case=test_case,
+                actual_status=status_code,
+                latency_ms=latency_ms,
+                response_body=response_body,
+                status=TestStatus.WARN_LEAK,
+                message=(
+                    f"SCHEMA LEAK: Server accepted invalid payload ({test_case.mutation_name}) "
+                    f"with HTTP {status_code}. Expected 422 or 400."
+                ),
+                curl_command=curl_cmd,
+            )
+        elif status_code in (400, 422):
+            return TestResult(
+                test_case=test_case,
+                actual_status=status_code,
+                latency_ms=latency_ms,
+                response_body=response_body,
+                status=TestStatus.PASS,
+                message=f"PASS: Server cleanly rejected {test_case.mutation_name} with HTTP {status_code}.",
+                curl_command=curl_cmd,
+            )
+        else:
+            return TestResult(
+                test_case=test_case,
+                actual_status=status_code,
+                latency_ms=latency_ms,
+                response_body=response_body,
+                status=TestStatus.FAIL_STATUS,
+                message=f"UNEXPECTED: Got HTTP {status_code}, expected {test_case.expected_status}.",
+                curl_command=curl_cmd,
+            )
+    else:
+        # Happy-path test
+        if 200 <= status_code < 300:
+            return TestResult(
+                test_case=test_case,
+                actual_status=status_code,
+                latency_ms=latency_ms,
+                response_body=response_body,
+                status=TestStatus.PASS,
+                message=f"PASS: Endpoint succeeded with HTTP {status_code}.",
+                curl_command=curl_cmd,
+            )
+        else:
+            return TestResult(
+                test_case=test_case,
+                actual_status=status_code,
+                latency_ms=latency_ms,
+                response_body=response_body,
+                status=TestStatus.FAIL_STATUS,
+                message=f"FAIL: Happy path failed with HTTP {status_code}.",
+                curl_command=curl_cmd,
+            )
+
+
+def build_curl_command(test_case: TestCase, base_url: str = "http://localhost:8000") -> str:
+    """Generate a clean cURL reproduction command for a test case."""
+    import json
+
+    url = f"{base_url.rstrip('/')}{test_case.endpoint}"
+    cmd_parts = [f"curl -X {test_case.method.upper()} '{url}'"]
+
+    for h_name, h_val in test_case.headers.items():
+        cmd_parts.append(f"-H '{h_name}: {h_val}'")
+
+    if test_case.payload is not None:
+        cmd_parts.append("-H 'Content-Type: application/json'")
+        payload_str = json.dumps(test_case.payload).replace("'", "'\\''")
+        cmd_parts.append(f"-d '{payload_str}'")
+
+    return " \\\n  ".join(cmd_parts)

specforge/testing/planner.py

@@ -0,0 +1,155 @@
+"""Test Plan orchestrator that assembles boundary test suites for operations."""
+
+import copy
+import uuid
+from dataclasses import dataclass, field
+from typing import Any
+
+from specforge.parser.models import Operation
+from specforge.testing.fuzzers.array_fuzzer import ArrayFuzzer
+from specforge.testing.fuzzers.boolean_fuzzer import BooleanFuzzer
+from specforge.testing.fuzzers.numeric_fuzzer import NumericFuzzer
+from specforge.testing.fuzzers.object_fuzzer import ObjectFuzzer
+from specforge.testing.fuzzers.string_fuzzer import StringFuzzer
+from specforge.testing.invariants import TestCase
+
+
+@dataclass
+class TestPlan:
+    """Represents the complete test suite planned for an operation or API."""
+
+    operation_key: str
+    endpoint: str
+    method: str
+    test_cases: list[TestCase] = field(default_factory=list)
+
+    def to_dict(self) -> dict[str, Any]:
+        """Convert test plan to dictionary."""
+        return {
+            "operation_key": self.operation_key,
+            "endpoint": self.endpoint,
+            "method": self.method,
+            "total_tests": len(self.test_cases),
+            "test_cases": [tc.to_dict() for tc in self.test_cases],
+        }
+
+
+class TestPlanner:
+    """Assembles combinatorial test cases by coordinating type fuzzers."""
+
+    @classmethod
+    def plan_operation_tests(cls, operation: Operation) -> TestPlan:
+        """Construct full boundary and negative test suite for a single operation."""
+        test_cases: list[TestCase] = []
+        op_key = operation.key
+        endpoint = operation.path
+        method = operation.method.lower()
+
+        # 1. Request Body Fuzzing
+        if operation.request_body and operation.request_body.schema:
+            body_schema = operation.request_body.schema
+            baseline = ObjectFuzzer.generate_valid_baseline(body_schema)
+
+            # Test 1.0: Baseline Happy Path
+            test_cases.append(
+                TestCase(
+                    id=str(uuid.uuid4())[:8],
+                    endpoint=endpoint,
+                    method=method,
+                    field_name="[body_root]",
+                    mutation_category="Baseline",
+                    mutation_name="Happy Path: Valid Schema Payload",
+                    description="Verify endpoint succeeds with schema-compliant baseline data",
+                    payload=baseline,
+                    expected_status=200,
+                    is_negative_test=False,
+                )
+            )
+
+            # Test 1.1: Object-level mutations (missing keys, extra keys, primitive inversion)
+            object_mutations = ObjectFuzzer.generate_object_mutations(body_schema, baseline)
+            for mut_name, mut_desc, mut_payload, mut_cat in object_mutations:
+                test_cases.append(
+                    TestCase(
+                        id=str(uuid.uuid4())[:8],
+                        endpoint=endpoint,
+                        method=method,
+                        field_name="[body_root]",
+                        mutation_category=f"Object:{mut_cat}",
+                        mutation_name=mut_name,
+                        description=mut_desc,
+                        payload=mut_payload,
+                        expected_status=422,
+                        is_negative_test=True,
+                    )
+                )
+
+            # Test 1.2: Field-level property mutations
+            for prop_name, prop_schema in body_schema.properties.items():
+                field_mutations = []
+                schema_type = prop_schema.type
+
+                if schema_type == "string":
+                    field_mutations = StringFuzzer.generate_mutations(prop_name, prop_schema)
+                elif schema_type in ("integer", "number"):
+                    field_mutations = NumericFuzzer.generate_mutations(prop_name, prop_schema)
+                elif schema_type == "boolean":
+                    field_mutations = BooleanFuzzer.generate_mutations(prop_name, prop_schema)
+                elif schema_type == "array":
+                    field_mutations = ArrayFuzzer.generate_mutations(prop_name, prop_schema)
+
+                # Inject each mutated field value into a fresh copy of the baseline payload
+                for mut_name, mut_desc, mut_val, mut_cat in field_mutations:
+                    mutated_payload = copy.deepcopy(baseline)
+                    mutated_payload[prop_name] = mut_val
+
+                    test_cases.append(
+                        TestCase(
+                            id=str(uuid.uuid4())[:8],
+                            endpoint=endpoint,
+                            method=method,
+                            field_name=prop_name,
+                            mutation_category=f"{str(schema_type or 'field').capitalize()}:{mut_cat}",
+                            mutation_name=mut_name,
+                            description=mut_desc,
+                            payload=mutated_payload,
+                            expected_status=422,
+                            is_negative_test=True,
+                        )
+                    )
+
+        # 2. Query Parameter Fuzzing
+        for param in operation.parameters:
+            if param.location.value == "query" and param.schema:
+                param_name = param.name
+                param_type = param.schema.type
+
+                param_mutations = []
+                if param_type == "string":
+                    param_mutations = StringFuzzer.generate_mutations(param_name, param.schema)
+                elif param_type in ("integer", "number"):
+                    param_mutations = NumericFuzzer.generate_mutations(param_name, param.schema)
+
+                for mut_name, mut_desc, mut_val, mut_cat in param_mutations:
+                    test_cases.append(
+                        TestCase(
+                            id=str(uuid.uuid4())[:8],
+                            endpoint=endpoint,
+                            method=method,
+                            field_name=param_name,
+                            mutation_category=f"QueryParam:{mut_cat}",
+                            mutation_name=mut_name,
+                            description=mut_desc,
+                            payload=None,
+                            query_params={param_name: mut_val},
+                            expected_status=422,
+                            is_negative_test=True,
+                        )
+                    )
+
+        return TestPlan(
+            operation_key=op_key,
+            endpoint=endpoint,
+            method=method,
+            test_cases=test_cases,
+        )

specforge/utils/html_injector.py

@@ -0,0 +1,43 @@
+"""Injects configuration and specifications into the pre-compiled HTML asset."""
+
+import json
+from pathlib import Path
+from typing import Any, Optional
+
+from specforge.config import SpecForgeConfig
+
+
+def get_asset_html_path() -> Path:
+    """Return the filesystem path to the bundled index.html asset."""
+    return Path(__file__).parent.parent / "assets" / "index.html"
+
+
+def render_html(
+    config: SpecForgeConfig,
+    spec_dict: Optional[dict[str, Any]] = None,
+) -> str:
+    """Read the inlined HTML template and inject the runtime configuration and spec."""
+    asset_path = get_asset_html_path()
+
+    if not asset_path.exists():
+        raise FileNotFoundError(
+            f"SpecForge frontend asset not found at {asset_path}. "
+            "Ensure the package was installed with assets bundled."
+        )
+
+    html_template = asset_path.read_text(encoding="utf-8")
+
+    config_data = config.to_dict()
+    if spec_dict is not None:
+        config_data["embedded_spec"] = spec_dict
+
+    config_json = json.dumps(config_data)
+    replacement = f"<script>window.__SPECFORGE_CONFIG__ = {config_json};</script>"
+
+    # Replace placeholder or insert into <head>
+    if "<!-- __SPECFORGE_CONFIG_INJECTION__ -->" in html_template:
+        return html_template.replace("<!-- __SPECFORGE_CONFIG_INJECTION__ -->", replacement)
+    elif "</head>" in html_template:
+        return html_template.replace("</head>", f"{replacement}\n</head>")
+    else:
+        return f"{replacement}\n{html_template}"

specforge_api-0.1.0.dist-info/METADATA

@@ -0,0 +1,260 @@
+Metadata-Version: 2.5
+Name: specforge-api
+Version: 0.1.0
+Summary: The interactive API client and automated contract testing engine for Python.
+Project-URL: Homepage, https://github.com/specforge-api/specforge
+Project-URL: Documentation, https://github.com/specforge-api/specforge#readme
+Project-URL: Repository, https://github.com/specforge-api/specforge
+Project-URL: Issues, https://github.com/specforge-api/specforge/issues
+Author: SpecForge Team
+License: MIT License
+        
+        Copyright (c) 2026 SpecForge Contributors
+        
+        Permission is hereby granted, free of charge, to any person obtaining a copy
+        of this software and associated documentation files (the "Software"), to deal
+        in the Software without restriction, including without limitation the rights
+        to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+        copies of the Software, and to permit persons to whom the Software is
+        furnished to do so, subject to the following conditions:
+        
+        The above copyright notice and this permission notice shall be included in all
+        copies or substantial portions of the Software.
+        
+        THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+        IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+        FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+        AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+        LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+        OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+        SOFTWARE.
+License-File: LICENSE
+Keywords: api-client,contract-testing,fastapi,fuzzing,openapi,pytest,swagger,testing
+Classifier: Development Status :: 3 - Alpha
+Classifier: Intended Audience :: Developers
+Classifier: License :: OSI Approved :: MIT License
+Classifier: Programming Language :: Python :: 3
+Classifier: Programming Language :: Python :: 3.9
+Classifier: Programming Language :: Python :: 3.10
+Classifier: Programming Language :: Python :: 3.11
+Classifier: Programming Language :: Python :: 3.12
+Classifier: Programming Language :: Python :: 3.13
+Classifier: Topic :: Internet :: WWW/HTTP :: HTTP Servers
+Classifier: Topic :: Software Development :: Testing
+Requires-Python: >=3.9
+Requires-Dist: httpx>=0.24.0
+Requires-Dist: pydantic>=2.0.0
+Requires-Dist: pyyaml>=6.0
+Provides-Extra: all
+Requires-Dist: fastapi>=0.100.0; extra == 'all'
+Requires-Dist: flask>=2.0.0; extra == 'all'
+Requires-Dist: rich>=13.0.0; extra == 'all'
+Requires-Dist: typer>=0.9.0; extra == 'all'
+Provides-Extra: cli
+Requires-Dist: rich>=13.0.0; extra == 'cli'
+Requires-Dist: typer>=0.9.0; extra == 'cli'
+Provides-Extra: dev
+Requires-Dist: mypy>=1.5.0; extra == 'dev'
+Requires-Dist: pytest-asyncio>=0.21.0; extra == 'dev'
+Requires-Dist: pytest>=7.4.0; extra == 'dev'
+Requires-Dist: ruff>=0.1.0; extra == 'dev'
+Requires-Dist: types-pyyaml; extra == 'dev'
+Provides-Extra: fastapi
+Requires-Dist: fastapi>=0.100.0; extra == 'fastapi'
+Provides-Extra: flask
+Requires-Dist: flask>=2.0.0; extra == 'flask'
+Description-Content-Type: text/markdown
+
+# SpecForge ⚡
+
+[![PyPI version](https://img.shields.io/pypi/v/specforge-api.svg)](https://pypi.org/project/specforge-api/)
+[![Python versions](https://img.shields.io/pypi/pyversions/specforge-api.svg)](https://pypi.org/project/specforge-api/)
+[![License: MIT](https://img.shields.io/badge/License-MIT-blue.svg)](https://opensource.org/licenses/MIT)
+
+**The Interactive API Client & Automated Contract Testing Engine for Python.**
+
+A modern, drop-in Python library that replaces Swagger UI with a beautiful, responsive API workspace **and** automatically discovers boundary vulnerabilities, missing whitespace stripping, and unhandled 500 server crashes directly against your endpoints.
+
+---
+
+## 🚀 Why SpecForge?
+
+1. **Active Quality Gate, Not Just Passive Docs**: Traditional tools like Swagger UI only show the "happy path". SpecForge algorithmically analyzes your schema constraints and runs targeted boundary fuzzing right in your browser.
+2. **"Zero 500s" Invariant**: Verifies that edge-case inputs (e.g. `"   "`, empty strings, off-by-one numbers, malformed emails) return clean client errors (`422/400`), never unhandled server exceptions (`500`).
+3. **One-Click Pytest Exporter**: Discovered edge cases can be instantly exported into commit-ready `test_api_contracts.py` files with `@pytest.mark.parametrize`.
+4. **Zero Frontend Build Dependencies**: The interactive workspace is fully compiled and inlined into the Python package. No Node.js or npm needed on your machine.
+
+---
+
+## 📦 Installation
+
+```bash
+pip install specforge-api
+```
+
+With framework extras:
+```bash
+pip install "specforge-api[fastapi]"   # FastAPI
+pip install "specforge-api[flask]"     # Flask
+pip install "specforge-api[all]"       # Full CLI & all framework adapters
+```
+
+---
+
+## ⚡ Quickstart
+
+### FastAPI
+
+```python
+from fastapi import FastAPI
+from specforge import SpecForge
+
+app = FastAPI(title="My API", version="1.0.0")
+
+# Mount SpecForge (auto-detects /openapi.json)
+SpecForge(app)
+
+@app.post("/users")
+def create_user(username: str, age: int):
+    return {"status": "created", "username": username}
+```
+
+Now open `http://localhost:8000/docs` in your browser. You get:
+- A modern, interactive dark/light mode API client (Try-It-Out, request history, multi-language code snippets).
+- An integrated **Boundary & Contract Testing Tab** to run automated fuzzing on all endpoints with one click.
+
+---
+
+### Flask
+
+```python
+from flask import Flask
+from specforge.flask import SpecForge
+
+app = Flask(__name__)
+
+# Register Blueprint
+SpecForge(app, spec_url="/api/spec.json", path="/docs")
+```
+
+---
+
+## 🧪 Schema-Aware Boundary Fuzzing
+
+SpecForge generates targeted test cases according to field types:
+
+| Field Type | Automated Test Coverage |
+|---|---|
+| **String** | Rejecting whitespace-only (`"   "`), empty strings (`""`), min/max bounds, Unicode 4-byte emojis, null bytes (`\x00`), format violations (email, uuid, datetime), and injection probes. |
+| **Number / Integer** | Boundary checks (`min - 1`, `max + 1`), negative values on unsigned fields, zero checks, float-into-integer pollution, and integer overflow. |
+| **Boolean** | Strict type testing vs loose coercion (`"true"`, `"yes"`, `1`, `0`, `null`). |
+| **Array** | Empty lists (`[]`), `minItems` / `maxItems` boundaries, and `uniqueItems: true` duplicates. |
+| **Object** | Combinatorial required field omission, extra unexpected keys (`additionalProperties: false`), and empty bodies. |
+
+---
+
+## 📁 Integrating Existing Project Tests
+
+If your repository already contains test suites (written in `pytest` or `unittest`), SpecForge can automatically index and display them in a dedicated **Project Tests** tab and link them directly to their corresponding API routes.
+
+### Quick Setup
+
+Pass `test_paths` when mounting SpecForge in your application:
+
+```python
+from fastapi import FastAPI
+from specforge import SpecForge
+
+app = FastAPI()
+
+# Mount SpecForge with existing project tests
+SpecForge(
+    app,
+    test_paths=["tests"],  # Can be directories or individual test files
+)
+```
+
+Now open `/docs` to see:
+- **📁 Project Tests Tab**: Browse all repository tests, file paths, line numbers, docstrings, and parameter matrices.
+- **Route Coverage Linking**: View your existing tests directly inside the API Explorer alongside SpecForge's automated boundary fuzzers.
+
+### Linking Tests to API Routes
+
+SpecForge associates existing tests with OpenAPI routes using two mechanisms:
+
+#### 1. Automatic HTTP Client Detection (Zero Configuration)
+If your test uses `TestClient`, `httpx`, or `requests` to call an API path, SpecForge automatically recognizes the route:
+```python
+def test_user_creation_underage(client):
+    """Rejects underage registrations."""
+    response = client.post("/api/v1/users", json={"username": "bob", "age": 16})
+    assert response.status_code == 422
+```
+
+#### 2. Explicit Pytest Marker (Recommended for Complex Tests)
+For tests with dynamic URLs or mocks, declare the endpoint explicitly:
+```python
+import pytest
+
+@pytest.mark.endpoint("POST", "/api/v1/users")
+def test_user_signup_pipeline():
+    """End-to-end user registration and event dispatch."""
+    ...
+```
+
+### 🔒 Security & Zero-Execution Guarantee
+
+SpecForge uses **Python Static Abstract Syntax Tree (AST) parsing** to discover tests:
+- **Zero Code Execution**: SpecForge **never** imports or executes your test files. Tests are analyzed purely as static syntax trees.
+- **No Side Effects**: Discovering tests will never trigger database operations, background tasks, or network calls.
+- **Path Sandboxing**: Scanned paths are strictly verified to remain within the project root directory, preventing any path traversal.
+
+---
+
+## 🛠️ CLI & CI/CD Pipeline
+
+Run headless contract fuzzing in your continuous integration pipeline:
+
+```bash
+specforge test http://localhost:8000/openapi.json --fail-on-500
+```
+
+---
+
+## 💻 Local Development & Testing Guide
+
+### 1. Run the Interactive Live Demo (Zero Dependencies)
+You can launch and explore SpecForge immediately using Python's standard library:
+```bash
+python examples/standalone_demo.py
+```
+Open **`http://localhost:8000/docs`** in your browser to:
+- Test API endpoints and inspect formatted JSON responses.
+- Click **"⚡ Run Boundary Test Suite"** to watch automated fuzzing of whitespace strings, negative numbers, and missing fields.
+- Click **"🐍 Export to Pytest"** to view and copy auto-generated test code.
+
+### 2. Run the Automated Unit Test Suite
+```bash
+pytest -v
+```
+
+### 3. Install in Another Project Locally (Editable Mode)
+To use this local version inside any other Python app on your machine without publishing to PyPI:
+```bash
+# In your other project's directory and virtualenv:
+pip install -e c:\Research-projects\specforge
+```
+*Any change you make in SpecForge source code will instantly reflect in your other application without reinstalling!*
+
+### 4. Build a Distribution Wheel (.whl)
+```bash
+pip install build
+python -m build
+# Outputs wheel file in dist/specforge-0.1.0-py3-none-any.whl
+```
+
+---
+
+## 📄 License
+
+SpecForge is licensed under the [MIT License](LICENSE).

specforge_api-0.1.0.dist-info/RECORD

@@ -0,0 +1,23 @@
+specforge/__init__.py,sha256=ASOKokzk1SCxc30JpuDLT_6oUN2ByHR-gz-E3kkbK24,636
+specforge/config.py,sha256=Br3CP2P1sLOO3YZJTYfjYWy7HNXZC_8eGpaouS3Ke6U,1499
+specforge/adapters/fastapi.py,sha256=X8N8sAyjMByzwintgzuPi-DX44uzh8sGFfem939zLlo,3603
+specforge/adapters/flask.py,sha256=ZMvji15SdjwF02_Bp-uoRGQlcgeEiEj28Q2jFkG6WXE,2353
+specforge/assets/index.html,sha256=7NVQW2LJFgMiaeHhvwTquzinUlPyD5NN3aJe_16vO9I,114194
+specforge/cli/main.py,sha256=HMMEwJItVA2yTiTbdy8Rzx7lpzsRYvNDiCqV5kK-P7o,5933
+specforge/parser/models.py,sha256=XJF9cYfYYVyE-jlylCvOP0AkO7Sh3IPLtGQr10aSWJU,3814
+specforge/parser/openapi3.py,sha256=6kQnH6RF0GiitUfVTBtTfO3zEVbgCi5zN9kBd43xJO4,10735
+specforge/parser/resolver.py,sha256=VPPQ-Oe3rf3-nAklJjw9W8p8x5qVisoUF0-Rev3ZKSI,4052
+specforge/testing/invariants.py,sha256=XuWT3jfIfEhQW16cJfpy9AJsLeE6gTYD9u7RLWHIA8I,6182
+specforge/testing/planner.py,sha256=LEmW6V779McAjvd1A-1uAxEjam_NdIMK4z_C9HN0e18,6563
+specforge/testing/exporters/pytest_export.py,sha256=c5v-hJ2PSSta_rATGZ_BejPKfIHPFYLR9ucADcxxdXw,2901
+specforge/testing/fuzzers/array_fuzzer.py,sha256=CsuochFAPHuTJ4ojEJu04FCyuqDlzUB1Mv4cUPim2e4,1850
+specforge/testing/fuzzers/boolean_fuzzer.py,sha256=GTEiSDyaKuCCMTvui33ExIY_ze2nHeRC5WO4oYXqaPM,1119
+specforge/testing/fuzzers/numeric_fuzzer.py,sha256=9GQXzxU4ri7kNLaTvgxSXK-k2ys7omtxnV644M2BokE,3120
+specforge/testing/fuzzers/object_fuzzer.py,sha256=WHY2tGea58Ng8rCuOwcA2YK11HGO75HEBBwBnNHaFhc,4131
+specforge/testing/fuzzers/string_fuzzer.py,sha256=2xNP2NpKLTrhempy8UqmGv22i5kfHUkNyt1bfUchWms,5406
+specforge/utils/html_injector.py,sha256=xYo-AHX2J4dVYRWk3ilWxfloDf7uX3HG7sMgi0T7yf8,1497
+specforge_api-0.1.0.dist-info/METADATA,sha256=kF1XBRgAfYFp2kYAw7L8GF3lddS7zi5dFHHxiQ2H3GE,10304
+specforge_api-0.1.0.dist-info/WHEEL,sha256=2iZrJkDIkeDh0k9SikKMqFuRP-ua6mb4Ir1AsER4BEw,87
+specforge_api-0.1.0.dist-info/entry_points.txt,sha256=_RzXTgdjdZrMPLWQD0tMSDiQXFnitiFMgCvN8XIpxG0,64
+specforge_api-0.1.0.dist-info/licenses/LICENSE,sha256=O_09tG0cQIwYwDQbHFG6WptgedhxMpOUQI-A-EX8QFs,1079
+specforge_api-0.1.0.dist-info/RECORD,,

specforge_api-0.1.0.dist-info/WHEEL

@@ -0,0 +1,4 @@
+Wheel-Version: 1.0
+Generator: hatchling 1.33.0
+Root-Is-Purelib: true
+Tag: py3-none-any

specforge_api-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+specforge = specforge.cli.main:cli_entrypoint

specforge_api-0.1.0.dist-info/licenses/LICENSE

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