ty-fetch 0.0.1 → 0.0.2-beta.0

package/README.md

@@ -0,0 +1,172 @@
+# ty-fetch
+
+TypeScript tooling that validates API calls against OpenAPI specs. Get autocomplete, diagnostics, and fully typed responses with zero manual types.
+
+```ts
+import tf from "ty-fetch";
+
+const customers = await tf.get("https://api.stripe.com/v1/customers").json();
+// customers is fully typed — data, has_more, object, url all autocomplete
+
+tf.get("https://api.stripe.com/v1/cutsomers");
+//                                  ~~~~~~~~~~
+// Error: Path '/v1/cutsomers' does not exist in Stripe API.
+//        Did you mean '/v1/customers'?
+```
+
+## What it does
+
+- **Path validation** — red squiggles for typos in API URLs, with "did you mean?" suggestions
+- **Typed responses** — response types generated from OpenAPI schemas, no manual `as` casts
+- **Typed request bodies** — body params validated against the spec
+- **Path & query params** — typed `params.path` and `params.query` based on the endpoint
+- **Autocomplete** — URL path completions inside string literals, filtered by HTTP method
+- **Hover info** — hover over a URL to see available methods and descriptions
+
+Works as both a **TS language service plugin** (editor DX) and a **CLI** (CI validation).
+
+## Setup
+
+```bash
+npm install github:alnorris/ty-fetch
+```
+
+Add the plugin to your `tsconfig.json`:
+
+```jsonc
+{
+  "compilerOptions": {
+    "plugins": [{ "name": "ty-fetch/plugin" }]
+  }
+}
+```
+
+In VS Code, make sure you're using the workspace TypeScript version (not the built-in one). Open the command palette and run **TypeScript: Select TypeScript Version** > **Use Workspace Version**.
+
+## Usage
+
+### The `ty-fetch` client
+
+A lightweight HTTP client (similar to [ky](https://github.com/sindresorhus/ky)) with typed methods:
+
+```ts
+import tf from "ty-fetch";
+
+// GET with typed response
+const customers = await tf.get("https://api.stripe.com/v1/customers").json();
+
+// POST with typed body
+const customer = await tf.post("https://api.stripe.com/v1/customers", {
+  body: { name: "Jane Doe", email: "jane@example.com" },
+}).json();
+
+// Path params
+const repo = await tf.get("https://api.github.com/repos/{owner}/{repo}", {
+  params: { path: { owner: "anthropics", repo: "claude-code" } },
+}).json();
+
+// Query params
+const pets = await tf.get("https://petstore3.swagger.io/api/v3/pet/findByStatus", {
+  params: { query: { status: "available" } },
+}).json();
+```
+
+Response methods:
+
+| Method | Returns |
+|---|---|
+| `.json()` | `Promise<T>` (typed from spec) |
+| `.text()` | `Promise<string>` |
+| `.blob()` | `Promise<Blob>` |
+| `.arrayBuffer()` | `Promise<ArrayBuffer>` |
+| `await` directly | `T` (same as `.json()`) |
+
+### CLI
+
+Run validation in CI or from the terminal:
+
+```bash
+npx ty-fetch                    # uses ./tsconfig.json
+npx ty-fetch tsconfig.json      # explicit path
+npx ty-fetch --verbose          # show spec fetching details
+```
+
+```
+example.ts:21:11 - error TF99001: Path '/v1/cutsomers' does not exist in Stripe API. Did you mean '/v1/customers'?
+example.ts:57:11 - error TF99001: Path '/pets' does not exist in Swagger Petstore. Did you mean '/pet'?
+
+2 error(s) found.
+```
+
+## Custom specs
+
+Map domains to local files or URLs in your tsconfig plugin config:
+
+```jsonc
+{
+  "compilerOptions": {
+    "plugins": [
+      {
+        "name": "ty-fetch/plugin",
+        "specs": {
+          "api.internal.company.com": "./specs/internal-api.json",
+          "api.partner.com": "https://partner.com/openapi.json"
+        }
+      }
+    ]
+  }
+}
+```
+
+- **File paths** are resolved relative to the tsconfig directory
+- **URLs** are fetched over HTTPS
+- Custom specs override built-in defaults for the same domain
+
+This works in both the editor plugin and the CLI.
+
+### Built-in specs
+
+These APIs are supported out of the box (no config needed):
+
+| Domain | API | Paths |
+|---|---|---|
+| `api.stripe.com` | Stripe API | 414 |
+| `petstore3.swagger.io` | Swagger Petstore | 13 |
+| `api.github.com` | GitHub REST API | 551 |
+
+## How it works
+
+1. Plugin intercepts the TS language service (`getSemanticDiagnostics`, `getCompletionsAtPosition`, `getQuickInfoAtPosition`)
+2. Finds `fetch()` / `tf.get()` / `tf.post()` etc. calls with string literal URLs
+3. Extracts the domain and fetches the OpenAPI spec on-demand (cached after first fetch)
+4. Validates paths against the spec, suggests corrections via Levenshtein distance
+5. Generates typed overloads into `node_modules/ty-fetch/index.d.ts` using interface declaration merging — only for URLs actually used in your code
+
+Spec fetching is async. On first encounter of a domain, the plugin fires a background fetch and returns no extra diagnostics. When the spec arrives, `refreshDiagnostics()` triggers the editor to re-check. This follows the same pattern as [graphqlsp](https://github.com/0no-co/graphqlsp).
+
+## Architecture
+
+```
+src/
+  plugin/index.ts      TS language service plugin (diagnostics, completions, hover)
+  cli/index.ts         CLI entry point for CI validation
+  core/                Shared logic (URL parsing, spec cache, path matching, body validation)
+  generate-types.ts    OpenAPI schema -> TypeScript type declarations
+test-project/          Example project using the plugin
+test/                  Unit tests
+```
+
+## Development
+
+```bash
+npm run build          # compile TypeScript
+npm run watch          # compile in watch mode
+npm test               # run unit tests
+```
+
+To test the editor experience:
+
+1. Open `test-project/` in VS Code
+2. Select the workspace TypeScript version
+3. Restart the TS server (`TypeScript: Restart TS Server`)
+4. Edit `test-project/example.ts` and observe diagnostics/completions

package/base.d.ts

@@ -0,0 +1,40 @@
+export class HTTPError extends Error {
+  response: Response;
+}
+
+export interface Options<
+  TBody = never,
+  TPathParams = never,
+  TQueryParams = never,
+> extends Omit<RequestInit, 'body'> {
+  body?: TBody;
+  params?: {
+    path?: TPathParams;
+    query?: TQueryParams;
+  };
+  prefixUrl?: string;
+}
+
+export interface ResponsePromise<T = unknown> extends PromiseLike<T> {
+  json(): Promise<T>;
+  text(): Promise<string>;
+  blob(): Promise<Blob>;
+  arrayBuffer(): Promise<ArrayBuffer>;
+  formData(): Promise<FormData>;
+}
+
+export interface TyFetch {
+  (url: string, options?: Options): ResponsePromise;
+  get(url: string, options?: Options): ResponsePromise;
+  post(url: string, options?: Options): ResponsePromise;
+  put(url: string, options?: Options): ResponsePromise;
+  patch(url: string, options?: Options): ResponsePromise;
+  delete(url: string, options?: Options): ResponsePromise;
+  head(url: string, options?: Options): ResponsePromise;
+  create(defaults?: Options<unknown>): TyFetch;
+  extend(defaults?: Options<unknown>): TyFetch;
+  HTTPError: typeof HTTPError;
+}
+
+declare const tf: TyFetch;
+export default tf;

package/dist/cli/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli/index.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const ts = __importStar(require("typescript"));
+const path = __importStar(require("path"));
+const core_1 = require("../core");
+async function main() {
+    const args = process.argv.slice(2);
+    const tsconfigPath = args[0] ?? "tsconfig.json";
+    const configFile = ts.readConfigFile(path.resolve(tsconfigPath), ts.sys.readFile);
+    if (configFile.error) {
+        console.error("Error reading tsconfig:", ts.flattenDiagnosticMessageText(configFile.error.messageText, "\n"));
+        process.exit(1);
+    }
+    const parsedConfig = ts.parseJsonConfigFileContent(configFile.config, ts.sys, path.dirname(path.resolve(tsconfigPath)));
+    // Load custom spec overrides from tsconfig plugin config
+    const plugins = configFile.config?.compilerOptions?.plugins ?? [];
+    const pluginConfig = plugins.find((p) => p.name === "ty-fetch" || p.name === "ty-fetch/plugin");
+    if (pluginConfig?.specs) {
+        (0, core_1.registerSpecs)(pluginConfig.specs, path.dirname(path.resolve(tsconfigPath)));
+    }
+    const program = ts.createProgram(parsedConfig.fileNames, parsedConfig.options);
+    // Step 1: Collect all fetch URLs and their domains
+    const allCalls = [];
+    const domains = new Set();
+    for (const sourceFile of program.getSourceFiles()) {
+        if (sourceFile.isDeclarationFile)
+            continue;
+        const calls = (0, core_1.findFetchCalls)(ts, sourceFile);
+        for (const call of calls) {
+            allCalls.push({ file: sourceFile, call });
+            const parsed = (0, core_1.parseFetchUrl)(call.url);
+            if (parsed)
+                domains.add(parsed.domain);
+        }
+    }
+    if (allCalls.length === 0) {
+        console.log("No fetch calls found.");
+        process.exit(0);
+    }
+    const log = (msg) => {
+        if (args.includes("--verbose"))
+            console.error(`[ty-fetch] ${msg}`);
+    };
+    // Step 2: Fetch all specs (async, in parallel)
+    log(`Found ${allCalls.length} fetch call(s) across ${domains.size} domain(s)`);
+    await Promise.all([...domains].map((d) => (0, core_1.fetchSpecForDomain)(d, log)));
+    // Step 3: Validate
+    const diagnostics = [];
+    for (const { file: sourceFile, call } of allCalls) {
+        const parsed = (0, core_1.parseFetchUrl)(call.url);
+        if (!parsed)
+            continue;
+        const entry = await (0, core_1.fetchSpecForDomain)(parsed.domain, log);
+        if (entry.status !== "loaded" || !entry.spec)
+            continue;
+        const apiPath = (0, core_1.stripBasePath)(parsed.path, entry.spec);
+        // Path validation
+        if (!(0, core_1.pathExistsInSpec)(apiPath, entry.spec)) {
+            const allPaths = Object.keys(entry.spec.paths);
+            const suggestion = (0, core_1.findClosestPath)(apiPath, allPaths);
+            const msg = `Path '${apiPath}' does not exist in ${entry.spec.info?.title ?? parsed.domain}.`
+                + (suggestion ? ` Did you mean '${suggestion}'?` : "");
+            const pos = sourceFile.getLineAndCharacterOfPosition(call.urlStart);
+            diagnostics.push({
+                file: path.relative(process.cwd(), sourceFile.fileName),
+                line: pos.line + 1, col: pos.character + 1,
+                message: msg, code: 99001,
+            });
+        }
+        // Body validation
+        if (call.httpMethod && call.jsonBody) {
+            const specPath = (0, core_1.findSpecPath)(apiPath, entry.spec);
+            if (specPath) {
+                const operation = entry.spec.paths[specPath]?.[call.httpMethod];
+                const reqSchema = operation?.requestBody?.content?.["application/json"]?.schema ??
+                    operation?.requestBody?.content?.["application/x-www-form-urlencoded"]?.schema;
+                if (reqSchema) {
+                    const resolved = (0, core_1.resolveSchemaRef)(reqSchema, entry.spec);
+                    if (resolved?.properties) {
+                        const jsonObjStart = call.jsonBody.length > 0 ? call.jsonBody[0].nameStart - 2 : call.callStart;
+                        const bodyDiags = (0, core_1.validateJsonBody)(call.jsonBody, resolved, entry.spec, jsonObjStart);
+                        for (const d of bodyDiags) {
+                            const pos = sourceFile.getLineAndCharacterOfPosition(d.start);
+                            diagnostics.push({
+                                file: path.relative(process.cwd(), sourceFile.fileName),
+                                line: pos.line + 1, col: pos.character + 1,
+                                message: d.message, code: d.code,
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // Step 4: Output
+    if (diagnostics.length === 0) {
+        console.log("No errors found.");
+        process.exit(0);
+    }
+    for (const d of diagnostics) {
+        console.log(`${d.file}:${d.line}:${d.col} - error TF${d.code}: ${d.message}`);
+    }
+    console.log(`\n${diagnostics.length} error(s) found.`);
+    process.exit(1);
+}
+main().catch((err) => {
+    console.error("Fatal:", err);
+    process.exit(2);
+});

package/dist/core/ast-helpers.d.ts

@@ -0,0 +1,8 @@
+import type { FetchCallInfo } from "./types";
+type TS = typeof import("typescript");
+type SourceFile = import("typescript").SourceFile;
+/**
+ * Find all fetch()/tf.get()/api.post() calls in a source file.
+ */
+export declare function findFetchCalls(ts: TS, sourceFile: SourceFile): FetchCallInfo[];
+export {};

package/dist/core/ast-helpers.js

@@ -0,0 +1,107 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findFetchCalls = findFetchCalls;
+/**
+ * Find all fetch()/tf.get()/api.post() calls in a source file.
+ */
+function findFetchCalls(ts, sourceFile) {
+    const results = [];
+    function nodeStart(node) { return node.getStart(sourceFile); }
+    function nodeLen(node) { return node.getEnd() - nodeStart(node); }
+    function visit(node) {
+        if (ts.isCallExpression(node) && node.arguments.length > 0) {
+            const expr = node.expression;
+            let httpMethod = null;
+            if (ts.isIdentifier(expr) && (expr.text === "fetch" || expr.text === "typedFetch")) {
+                httpMethod = null;
+            }
+            else if (ts.isPropertyAccessExpression(expr) &&
+                ts.isIdentifier(expr.expression) &&
+                ["get", "post", "put", "patch", "delete", "head", "request"].includes(expr.name.text)) {
+                httpMethod = expr.name.text === "request" || expr.name.text === "head" ? null : expr.name.text;
+            }
+            else if (ts.isIdentifier(expr)) {
+                httpMethod = null;
+            }
+            else {
+                ts.forEachChild(node, visit);
+                return;
+            }
+            const arg = node.arguments[0];
+            if (ts.isStringLiteral(arg) || ts.isNoSubstitutionTemplateLiteral(arg)) {
+                const urlStart = nodeStart(arg) + 1; // skip opening quote
+                const urlLength = nodeLen(arg) - 2; // exclude quotes
+                let jsonBody = null;
+                if (node.arguments.length >= 2) {
+                    const optionsArg = node.arguments[1];
+                    if (ts.isObjectLiteralExpression(optionsArg)) {
+                        const jsonProp = optionsArg.properties.find((p) => ts.isPropertyAssignment(p) && ts.isIdentifier(p.name) && p.name.text === "body");
+                        if (jsonProp && ts.isObjectLiteralExpression(jsonProp.initializer)) {
+                            jsonBody = extractJsonProperties(ts, sourceFile, jsonProp.initializer);
+                        }
+                    }
+                }
+                results.push({
+                    url: arg.text,
+                    httpMethod,
+                    urlStart,
+                    urlLength,
+                    callStart: nodeStart(node),
+                    callLength: nodeLen(node),
+                    jsonBody,
+                });
+            }
+        }
+        ts.forEachChild(node, visit);
+    }
+    visit(sourceFile);
+    return results;
+}
+function extractJsonProperties(ts, sf, obj) {
+    function nodeStart(n) { return n.getStart(sf); }
+    function nodeLen(n) { return n.getEnd() - nodeStart(n); }
+    const props = [];
+    for (const prop of obj.properties) {
+        if (!ts.isPropertyAssignment(prop))
+            continue;
+        const name = ts.isIdentifier(prop.name) ? prop.name.text
+            : ts.isStringLiteral(prop.name) ? prop.name.text
+                : null;
+        if (!name)
+            continue;
+        const valueNode = prop.initializer;
+        let valueKind = "other";
+        let valueText = "";
+        if (ts.isNumericLiteral(valueNode)) {
+            valueKind = "number";
+            valueText = valueNode.text;
+        }
+        else if (ts.isStringLiteral(valueNode)) {
+            valueKind = "string";
+            valueText = valueNode.text;
+        }
+        else if (valueNode.kind === ts.SyntaxKind.TrueKeyword || valueNode.kind === ts.SyntaxKind.FalseKeyword) {
+            valueKind = "boolean";
+            valueText = valueNode.kind === ts.SyntaxKind.TrueKeyword ? "true" : "false";
+        }
+        else if (valueNode.kind === ts.SyntaxKind.NullKeyword) {
+            valueKind = "null";
+        }
+        else if (ts.isArrayLiteralExpression(valueNode)) {
+            valueKind = "array";
+        }
+        else if (ts.isObjectLiteralExpression(valueNode)) {
+            valueKind = "object";
+        }
+        props.push({
+            name,
+            nameStart: nodeStart(prop.name),
+            nameLength: nodeLen(prop.name),
+            valueStart: nodeStart(valueNode),
+            valueLength: nodeLen(valueNode),
+            valueText,
+            valueKind,
+        });
+    }
+    return props;
+}

package/dist/core/body-validator.d.ts

@@ -0,0 +1,6 @@
+import type { OpenAPISpec, JsonBodyProperty, ValidationDiagnostic } from "./types";
+/**
+ * Validate a JSON body object against an OpenAPI schema.
+ * Returns diagnostics with positions pointing at the specific offending properties.
+ */
+export declare function validateJsonBody(properties: JsonBodyProperty[], schema: any, spec: OpenAPISpec, jsonObjectStart: number): ValidationDiagnostic[];

package/dist/core/body-validator.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.validateJsonBody = validateJsonBody;
+const schema_utils_1 = require("./schema-utils");
+/**
+ * Validate a JSON body object against an OpenAPI schema.
+ * Returns diagnostics with positions pointing at the specific offending properties.
+ */
+function validateJsonBody(properties, schema, spec, jsonObjectStart) {
+    const diagnostics = [];
+    const schemaProps = schema.properties;
+    if (!schemaProps)
+        return diagnostics;
+    const requiredSet = new Set(schema.required ?? []);
+    // Check each property
+    for (const prop of properties) {
+        // Unknown property
+        if (!schemaProps[prop.name]) {
+            diagnostics.push({
+                start: prop.nameStart,
+                length: prop.nameLength,
+                message: `Property '${prop.name}' does not exist in the request body schema.`,
+                code: 99002,
+            });
+            continue;
+        }
+        // Type mismatch
+        const expectedSchema = (0, schema_utils_1.resolveSchemaRef)(schemaProps[prop.name], spec);
+        if (!expectedSchema?.type)
+            continue;
+        const mismatch = checkTypeMismatch(prop, expectedSchema);
+        if (mismatch) {
+            diagnostics.push({
+                start: prop.valueStart,
+                length: prop.valueLength,
+                message: mismatch,
+                code: 99003,
+            });
+        }
+    }
+    // Missing required properties
+    const providedNames = new Set(properties.map((p) => p.name));
+    for (const reqProp of requiredSet) {
+        if (!providedNames.has(reqProp)) {
+            diagnostics.push({
+                start: jsonObjectStart,
+                length: 1, // opening brace
+                message: `Missing required property '${reqProp}' in request body.`,
+                code: 99004,
+            });
+        }
+    }
+    return diagnostics;
+}
+function checkTypeMismatch(prop, schema) {
+    const expectedType = schema.type;
+    const enumValues = schema.enum;
+    switch (prop.valueKind) {
+        case "number":
+            if (expectedType === "string")
+                return `Type 'number' is not assignable to type 'string'.`;
+            break;
+        case "string":
+            if (expectedType === "number" || expectedType === "integer")
+                return `Type 'string' is not assignable to type 'number'.`;
+            if (enumValues && !enumValues.includes(prop.valueText))
+                return `Value '${prop.valueText}' is not assignable to type '${enumValues.map((v) => `"${v}"`).join(" | ")}'.`;
+            break;
+        case "boolean":
+            if (expectedType === "string")
+                return `Type 'boolean' is not assignable to type 'string'.`;
+            if (expectedType === "number" || expectedType === "integer")
+                return `Type 'boolean' is not assignable to type 'number'.`;
+            break;
+        case "array":
+            if (expectedType !== "array")
+                return `Type 'array' is not assignable to type '${expectedType}'.`;
+            break;
+        case "object":
+            if (expectedType !== "object" && !schema.properties)
+                return `Type 'object' is not assignable to type '${expectedType}'.`;
+            break;
+    }
+    return null;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,7 @@
+export * from "./types";
+export * from "./url-parser";
+export * from "./path-validator";
+export * from "./schema-utils";
+export * from "./body-validator";
+export * from "./spec-cache";
+export * from "./ast-helpers";

package/dist/core/index.js

@@ -0,0 +1,23 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./types"), exports);
+__exportStar(require("./url-parser"), exports);
+__exportStar(require("./path-validator"), exports);
+__exportStar(require("./schema-utils"), exports);
+__exportStar(require("./body-validator"), exports);
+__exportStar(require("./spec-cache"), exports);
+__exportStar(require("./ast-helpers"), exports);

package/dist/core/path-validator.d.ts

@@ -0,0 +1,5 @@
+import type { OpenAPISpec } from "./types";
+export declare function matchesPathTemplate(actualPath: string, templatePath: string): boolean;
+export declare function pathExistsInSpec(path: string, spec: OpenAPISpec): boolean;
+export declare function findSpecPath(apiPath: string, spec: OpenAPISpec): string | null;
+export declare function findClosestPath(target: string, paths: string[]): string | null;

package/dist/core/path-validator.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.matchesPathTemplate = matchesPathTemplate;
+exports.pathExistsInSpec = pathExistsInSpec;
+exports.findSpecPath = findSpecPath;
+exports.findClosestPath = findClosestPath;
+function matchesPathTemplate(actualPath, templatePath) {
+    const actualParts = actualPath.split("/");
+    const templateParts = templatePath.split("/");
+    if (actualParts.length !== templateParts.length)
+        return false;
+    return templateParts.every((tp, i) => tp.startsWith("{") || tp === actualParts[i]);
+}
+function pathExistsInSpec(path, spec) {
+    if (spec.paths[path])
+        return true;
+    return Object.keys(spec.paths).some((tp) => matchesPathTemplate(path, tp));
+}
+function findSpecPath(apiPath, spec) {
+    if (spec.paths[apiPath])
+        return apiPath;
+    return Object.keys(spec.paths).find((tp) => matchesPathTemplate(apiPath, tp)) ?? null;
+}
+function findClosestPath(target, paths) {
+    let best = null;
+    let bestDist = Infinity;
+    for (const p of paths) {
+        const d = levenshtein(target, p);
+        if (d < bestDist && d <= Math.max(target.length, p.length) * 0.4) {
+            bestDist = d;
+            best = p;
+        }
+    }
+    return best;
+}
+function levenshtein(a, b) {
+    const m = a.length, n = b.length;
+    const dp = Array.from({ length: m + 1 }, () => Array(n + 1).fill(0));
+    for (let i = 0; i <= m; i++)
+        dp[i][0] = i;
+    for (let j = 0; j <= n; j++)
+        dp[0][j] = j;
+    for (let i = 1; i <= m; i++)
+        for (let j = 1; j <= n; j++)
+            dp[i][j] = Math.min(dp[i - 1][j] + 1, dp[i][j - 1] + 1, dp[i - 1][j - 1] + (a[i - 1] === b[j - 1] ? 0 : 1));
+    return dp[m][n];
+}

package/dist/core/schema-utils.d.ts

@@ -0,0 +1,5 @@
+import type { OpenAPISpec } from "./types";
+export declare function resolveSchemaRef(schema: any, spec: OpenAPISpec): any;
+export declare function getRequestBodySchema(operation: any): any | null;
+export declare function getResponseSchema(operation: any): any | null;
+export declare function isRequestBodyRequired(operation: any): boolean;