wrekenfile-converter 2.0.0

package/README.md

@@ -0,0 +1,185 @@
+# Wrekenfile Converter (Library)
+
+A comprehensive TypeScript/JavaScript library for converting OpenAPI specifications (v2 and v3) and Postman collections into [Wrekenfile](./wrekenfile.md) YAML format, with advanced mini-chunking capabilities for vector database storage and AI context management.
+
+## Features
+
+- **Multi-format Support**: Convert OpenAPI v2 (Swagger), OpenAPI v3, and Postman collections
+- **Complete Response Handling**: All response types (success and error) included in `RETURNS` arrays
+- **AI-Optimized**: Response structs explicitly referenced for easy AI consumption
+- **Mini Wrekenfile Generation**: Create focused, endpoint-grouped chunks for vector DB storage
+- **Comprehensive Validation**: Built-in Wrekenfile validator with auto-fix capabilities
+- **TypeScript Support**: Full TypeScript definitions and exports
+- **Subproject Ready**: Designed to work as a dependency in larger projects
+
+## Installation
+
+### As a Dependency (Recommended)
+
+```bash
+npm install wrekenfile-converter
+```
+
+or
+
+```bash
+yarn add wrekenfile-converter
+```
+
+## Usage
+
+### Importing the Library
+
+```typescript
+import {
+  generateWrekenfile, // OpenAPI v3
+  generateWrekenfileV2, // OpenAPI v2 (Swagger)
+  generateWrekenfileFromPostman, // Postman collections
+  validateWrekenfile,
+  generateMiniWrekenfiles,
+  MiniWrekenfile,
+  ValidationResult
+} from 'wrekenfile-converter';
+```
+
+### Convert OpenAPI v3 to Wrekenfile
+
+```typescript
+import fs from 'fs';
+import yaml from 'js-yaml';
+import { generateWrekenfile } from 'wrekenfile-converter';
+
+const fileContent = fs.readFileSync('./openapi.yaml', 'utf8');
+const openapiSpec = yaml.load(fileContent);
+const wrekenfileYaml = generateWrekenfile(openapiSpec, './');
+```
+
+### Convert OpenAPI v2 (Swagger) to Wrekenfile
+
+```typescript
+import fs from 'fs';
+import yaml from 'js-yaml';
+import { generateWrekenfile as generateWrekenfileV2 } from 'wrekenfile-converter';
+
+const fileContent = fs.readFileSync('./swagger.yaml', 'utf8');
+const swaggerSpec = yaml.load(fileContent);
+const wrekenfileYaml = generateWrekenfileV2(swaggerSpec, './');
+```
+
+### Convert Postman Collection to Wrekenfile
+
+```typescript
+import fs from 'fs';
+import { generateWrekenfileFromPostman } from 'wrekenfile-converter';
+
+const collection = JSON.parse(fs.readFileSync('./collection.json', 'utf8'));
+const variables = {}; // Optionally provide Postman environment variables
+const wrekenfileYaml = generateWrekenfileFromPostman(collection, variables);
+```
+
+### Validate a Wrekenfile
+
+```typescript
+import { validateWrekenfile } from 'wrekenfile-converter';
+
+const result = validateWrekenfile('./Wrekenfile.yaml');
+console.log(result.isValid ? '✅ Valid' : '❌ Invalid');
+console.log(result.errors, result.warnings);
+```
+
+### Generate Mini Wrekenfiles
+
+```typescript
+import { generateMiniWrekenfiles, MiniWrekenfile } from 'wrekenfile-converter';
+
+const miniFiles: MiniWrekenfile[] = generateMiniWrekenfiles('./Wrekenfile.yaml');
+// Each miniFile contains { content, metadata }
+```
+
+## API Reference
+
+### Core Functions
+
+#### `generateWrekenfile(spec: any, baseDir: string): string`
+Convert OpenAPI v3 specification to Wrekenfile format.
+
+#### `generateWrekenfileV2(spec: any, baseDir: string): string`
+Convert OpenAPI v2 (Swagger) specification to Wrekenfile format.
+
+#### `generateWrekenfileFromPostman(collection: any, variables: Record<string, string>): string`
+Convert Postman collection to Wrekenfile format.
+
+#### `validateWrekenfile(filePath: string): ValidationResult`
+Validate a Wrekenfile and return detailed results.
+
+#### `generateMiniWrekenfiles(wrekenfilePath: string): MiniWrekenfile[]`
+Generate mini Wrekenfiles grouped by endpoint.
+
+### Types
+
+#### `MiniWrekenfile`
+```typescript
+interface MiniWrekenfile {
+  content: string;           // Complete YAML content
+  metadata: {
+    endpoint: string;        // API endpoint path
+    methods: string[];       // HTTP methods (GET, POST, etc.)
+    structs: string[];       // Required struct names
+    filename: string;        // Generated filename
+  };
+}
+```
+
+#### `ValidationResult`
+```typescript
+interface ValidationResult {
+  isValid: boolean;
+  errors: string[];
+  warnings: string[];
+}
+```
+
+## Development
+
+### Build Commands
+
+```bash
+# Build TypeScript to dist/
+npm run build
+
+# Clean dist folder
+npm run clean
+
+# Watch mode for development
+npm run dev
+
+# Run example usage
+npm run example
+```
+
+### Project Structure
+
+```
+src/
+├── index.ts                    # Main exports
+├── openapi-to-wreken.ts        # OpenAPI v3 converter
+├── openapi-v2-to-wrekenfile.ts # OpenAPI v2 converter
+├── postman-to-wrekenfile.ts    # Postman converter
+├── wrekenfile-validator.ts     # Validation logic
+├── mini-wrekenfile-generator.ts # Mini chunk generator
+└── example-usage.ts            # Usage examples
+
+dist/                           # Compiled JavaScript + types
+├── index.js
+├── index.d.ts
+└── ... (all compiled files)
+
+mini-wrekenfiles/               # Generated mini chunks (if you save them)
+├── mini-v2-app-projects.yaml
+├── mini-v2-app-authenticate.yaml
+└── ...
+```
+
+## License
+
+MIT 

package/dist/example-usage.d.ts

@@ -0,0 +1,4 @@
+import { MiniWrekenfile } from './mini-wrekenfile-generator';
+export declare function getMiniWrekenfilesForEndpoints(wrekenfileContent: string, targetEndpoints: string[]): MiniWrekenfile[];
+export declare function getMiniWrekenfilesForMethods(wrekenfileContent: string, targetMethods: string[]): MiniWrekenfile[];
+export declare function getMiniWrekenfileContent(wrekenfileContent: string, endpoint: string): string | null;

package/dist/example-usage.js

@@ -0,0 +1,57 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMiniWrekenfilesForEndpoints = getMiniWrekenfilesForEndpoints;
+exports.getMiniWrekenfilesForMethods = getMiniWrekenfilesForMethods;
+exports.getMiniWrekenfileContent = getMiniWrekenfileContent;
+const fs_1 = __importDefault(require("fs"));
+const js_yaml_1 = __importDefault(require("js-yaml"));
+const index_1 = require("./index");
+/**
+ * Example usage of the mini Wrekenfile generator
+ * This shows how to integrate with a vector database
+ */
+function exampleUsage() {
+    // OpenAPI v3 example
+    const openapiContent = fs_1.default.readFileSync('./examples/plaid.yml', 'utf8');
+    const openapiSpec = js_yaml_1.default.load(openapiContent);
+    const wrekenfileYaml = (0, index_1.generateWrekenfile)(openapiSpec, './examples');
+    console.log('OpenAPI v3 to Wrekenfile:', wrekenfileYaml.slice(0, 200) + '...');
+    // Postman example
+    const postmanContent = fs_1.default.readFileSync('./examples/Swytchcode API Docs.postman_collection.json', 'utf8');
+    const postmanCollection = JSON.parse(postmanContent);
+    const wrekenfileFromPostman = (0, index_1.generateWrekenfileFromPostman)(postmanCollection, {});
+    console.log('Postman to Wrekenfile:', wrekenfileFromPostman.slice(0, 200) + '...');
+    // Mini Wrekenfiles
+    fs_1.default.writeFileSync('./Wrekenfile.yaml', wrekenfileYaml);
+    const miniFiles = (0, index_1.generateMiniWrekenfiles)(wrekenfileYaml);
+    console.log('Mini Wrekenfiles count:', miniFiles.length);
+    if (miniFiles.length > 0) {
+        console.log('First mini Wrekenfile:', miniFiles[0].content.slice(0, 200) + '...');
+    }
+    // Validation
+    const validation = (0, index_1.validateWrekenfile)('./Wrekenfile.yaml');
+    console.log('Validation result:', validation.isValid, validation.errors, validation.warnings);
+}
+// Example: Function to get mini Wrekenfiles for specific endpoints
+function getMiniWrekenfilesForEndpoints(wrekenfileContent, targetEndpoints) {
+    const allMiniFiles = (0, index_1.generateMiniWrekenfiles)(wrekenfileContent);
+    return allMiniFiles.filter(miniFile => targetEndpoints.includes(miniFile.metadata.endpoint));
+}
+// Example: Function to get mini Wrekenfiles for specific methods
+function getMiniWrekenfilesForMethods(wrekenfileContent, targetMethods) {
+    const allMiniFiles = (0, index_1.generateMiniWrekenfiles)(wrekenfileContent);
+    return allMiniFiles.filter(miniFile => miniFile.metadata.methods.some(method => targetMethods.includes(method)));
+}
+// Example: Function to get mini Wrekenfile content as string for AI context
+function getMiniWrekenfileContent(wrekenfileContent, endpoint) {
+    const allMiniFiles = (0, index_1.generateMiniWrekenfiles)(wrekenfileContent);
+    const miniFile = allMiniFiles.find(file => file.metadata.endpoint === endpoint);
+    return miniFile ? miniFile.content : null;
+}
+// Run example if this file is executed directly
+if (require.main === module) {
+    exampleUsage();
+}

package/dist/index.d.ts

@@ -0,0 +1,6 @@
+export { generateWrekenfile } from './openapi-to-wreken';
+export { generateWrekenfile as generateWrekenfileV2 } from './openapi-v2-to-wrekenfile';
+export { generateWrekenfile as generateWrekenfileFromPostman, extractStructs, extractOperations, mapType, parseJsonExample, extractFieldsFromObject, loadEnvironmentFile, extractCollectionVariables, resolveVariables } from './postman-to-wrekenfile';
+export { validateWrekenfile, fixWrekenfile, ValidationResult, WrekenfileStructure, printValidationResult } from './wrekenfile-validator';
+export { generateMiniWrekenfiles, saveMiniWrekenfiles, MiniWrekenfile } from './mini-wrekenfile-generator';
+export { getMiniWrekenfilesForEndpoints, getMiniWrekenfilesForMethods, getMiniWrekenfileContent } from './example-usage';

package/dist/index.js

@@ -0,0 +1,33 @@
+"use strict";
+// Main entry point for the wrekenfile-converter library (no CLI)
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getMiniWrekenfileContent = exports.getMiniWrekenfilesForMethods = exports.getMiniWrekenfilesForEndpoints = exports.saveMiniWrekenfiles = exports.generateMiniWrekenfiles = exports.printValidationResult = exports.fixWrekenfile = exports.validateWrekenfile = exports.resolveVariables = exports.extractCollectionVariables = exports.loadEnvironmentFile = exports.extractFieldsFromObject = exports.parseJsonExample = exports.mapType = exports.extractOperations = exports.extractStructs = exports.generateWrekenfileFromPostman = exports.generateWrekenfileV2 = exports.generateWrekenfile = void 0;
+// Export main conversion functions
+var openapi_to_wreken_1 = require("./openapi-to-wreken");
+Object.defineProperty(exports, "generateWrekenfile", { enumerable: true, get: function () { return openapi_to_wreken_1.generateWrekenfile; } });
+var openapi_v2_to_wrekenfile_1 = require("./openapi-v2-to-wrekenfile");
+Object.defineProperty(exports, "generateWrekenfileV2", { enumerable: true, get: function () { return openapi_v2_to_wrekenfile_1.generateWrekenfile; } });
+var postman_to_wrekenfile_1 = require("./postman-to-wrekenfile");
+Object.defineProperty(exports, "generateWrekenfileFromPostman", { enumerable: true, get: function () { return postman_to_wrekenfile_1.generateWrekenfile; } });
+Object.defineProperty(exports, "extractStructs", { enumerable: true, get: function () { return postman_to_wrekenfile_1.extractStructs; } });
+Object.defineProperty(exports, "extractOperations", { enumerable: true, get: function () { return postman_to_wrekenfile_1.extractOperations; } });
+Object.defineProperty(exports, "mapType", { enumerable: true, get: function () { return postman_to_wrekenfile_1.mapType; } });
+Object.defineProperty(exports, "parseJsonExample", { enumerable: true, get: function () { return postman_to_wrekenfile_1.parseJsonExample; } });
+Object.defineProperty(exports, "extractFieldsFromObject", { enumerable: true, get: function () { return postman_to_wrekenfile_1.extractFieldsFromObject; } });
+Object.defineProperty(exports, "loadEnvironmentFile", { enumerable: true, get: function () { return postman_to_wrekenfile_1.loadEnvironmentFile; } });
+Object.defineProperty(exports, "extractCollectionVariables", { enumerable: true, get: function () { return postman_to_wrekenfile_1.extractCollectionVariables; } });
+Object.defineProperty(exports, "resolveVariables", { enumerable: true, get: function () { return postman_to_wrekenfile_1.resolveVariables; } });
+// Export validation function
+var wrekenfile_validator_1 = require("./wrekenfile-validator");
+Object.defineProperty(exports, "validateWrekenfile", { enumerable: true, get: function () { return wrekenfile_validator_1.validateWrekenfile; } });
+Object.defineProperty(exports, "fixWrekenfile", { enumerable: true, get: function () { return wrekenfile_validator_1.fixWrekenfile; } });
+Object.defineProperty(exports, "printValidationResult", { enumerable: true, get: function () { return wrekenfile_validator_1.printValidationResult; } });
+// Export mini Wrekenfile generator
+var mini_wrekenfile_generator_1 = require("./mini-wrekenfile-generator");
+Object.defineProperty(exports, "generateMiniWrekenfiles", { enumerable: true, get: function () { return mini_wrekenfile_generator_1.generateMiniWrekenfiles; } });
+Object.defineProperty(exports, "saveMiniWrekenfiles", { enumerable: true, get: function () { return mini_wrekenfile_generator_1.saveMiniWrekenfiles; } });
+// Export utility functions
+var example_usage_1 = require("./example-usage");
+Object.defineProperty(exports, "getMiniWrekenfilesForEndpoints", { enumerable: true, get: function () { return example_usage_1.getMiniWrekenfilesForEndpoints; } });
+Object.defineProperty(exports, "getMiniWrekenfilesForMethods", { enumerable: true, get: function () { return example_usage_1.getMiniWrekenfilesForMethods; } });
+Object.defineProperty(exports, "getMiniWrekenfileContent", { enumerable: true, get: function () { return example_usage_1.getMiniWrekenfileContent; } });

package/dist/mini-wrekenfile-generator.d.ts

@@ -0,0 +1,18 @@
+export interface MiniWrekenfile {
+    content: string;
+    metadata: {
+        endpoint: string;
+        methods: string[];
+        structs: string[];
+        filename: string;
+    };
+}
+/**
+ * Generates mini Wrekenfiles by grouping interfaces by endpoint
+ * Each mini Wrekenfile contains all methods for a single endpoint plus their required structs
+ */
+export declare function generateMiniWrekenfiles(wrekenfileContent: string): MiniWrekenfile[];
+/**
+ * Saves mini Wrekenfiles to disk (optional utility function)
+ */
+export declare function saveMiniWrekenfiles(miniWrekenfiles: MiniWrekenfile[], outputDir?: string): void;

package/dist/mini-wrekenfile-generator.js

@@ -0,0 +1,246 @@
+"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 });
+exports.generateMiniWrekenfiles = generateMiniWrekenfiles;
+exports.saveMiniWrekenfiles = saveMiniWrekenfiles;
+const yaml = __importStar(require("js-yaml"));
+const fs = __importStar(require("fs"));
+/**
+ * Generates mini Wrekenfiles by grouping interfaces by endpoint
+ * Each mini Wrekenfile contains all methods for a single endpoint plus their required structs
+ */
+function generateMiniWrekenfiles(wrekenfileContent) {
+    if (!wrekenfileContent || typeof wrekenfileContent !== 'string') {
+        throw new Error("Argument 'wrekenfileContent' is required and must be a string");
+    }
+    try {
+        // Parse the main Wrekenfile from YAML string
+        const data = yaml.load(wrekenfileContent);
+        if (!data.INTERFACES) {
+            throw new Error('No INTERFACES section found in Wrekenfile');
+        }
+        // Group interfaces by endpoint
+        const endpointGroups = groupInterfacesByEndpoint(data.INTERFACES);
+        const miniWrekenfiles = [];
+        // Generate a mini Wrekenfile for each endpoint group
+        for (const [endpoint, interfaces] of Object.entries(endpointGroups)) {
+            const miniWrekenfile = createMiniWrekenfile(data, endpoint, interfaces);
+            miniWrekenfiles.push(miniWrekenfile);
+        }
+        return miniWrekenfiles;
+    }
+    catch (error) {
+        console.error('Error generating mini Wrekenfiles:', error);
+        throw error;
+    }
+}
+/**
+ * Groups interfaces by their endpoint path
+ */
+function groupInterfacesByEndpoint(interfaces) {
+    const groups = {};
+    for (const [interfaceName, interfaceData] of Object.entries(interfaces)) {
+        let endpoint = interfaceData.ENDPOINT;
+        if (!endpoint) {
+            console.warn(`Interface ${interfaceName} has no ENDPOINT, skipping`);
+            continue;
+        }
+        // Normalize endpoint: remove backticks and trim whitespace
+        if (typeof endpoint === 'string') {
+            endpoint = endpoint.trim();
+            if (endpoint.startsWith('`') && endpoint.endsWith('`')) {
+                endpoint = endpoint.slice(1, -1).trim();
+            }
+        }
+        if (!groups[endpoint]) {
+            groups[endpoint] = {};
+        }
+        groups[endpoint][interfaceName] = interfaceData;
+    }
+    return groups;
+}
+/**
+ * Creates a complete mini Wrekenfile for a specific endpoint
+ */
+function createMiniWrekenfile(data, endpoint, interfaces) {
+    // Collect all structs referenced by the interfaces in this group
+    const requiredStructs = collectRequiredStructs(interfaces, data.STRUCTS || {});
+    // Create the mini Wrekenfile structure
+    const miniData = {
+        VERSION: data.VERSION,
+        INIT: data.INIT ? { DEFAULTS: data.INIT.DEFAULTS || [] } : undefined,
+        INTERFACES: interfaces,
+        STRUCTS: requiredStructs
+    };
+    // Convert to YAML
+    const content = yaml.dump(miniData, {
+        indent: 2,
+        lineWidth: -1,
+        noRefs: true
+    });
+    // Generate metadata
+    const methods = Object.values(interfaces).map((intf) => { var _a; return (_a = intf.HTTP) === null || _a === void 0 ? void 0 : _a.METHOD; }).filter(Boolean);
+    const structNames = Object.keys(requiredStructs);
+    const filename = generateFilename(endpoint);
+    return {
+        content,
+        metadata: {
+            endpoint,
+            methods,
+            structs: structNames,
+            filename
+        }
+    };
+}
+/**
+ * Collects all structs required by the given interfaces
+ */
+function collectRequiredStructs(interfaces, allStructs) {
+    const requiredStructs = {};
+    const processedStructs = new Set();
+    // Extract struct references from interfaces
+    const structRefs = new Set();
+    for (const interfaceData of Object.values(interfaces)) {
+        // Check INPUTS
+        if (interfaceData.INPUTS) {
+            for (const input of interfaceData.INPUTS) {
+                if (input.type) {
+                    const structNames = extractAllStructNames(input.type);
+                    for (const structName of structNames) {
+                        if (structName)
+                            structRefs.add(structName);
+                    }
+                }
+            }
+        }
+        // Check RETURNS
+        if (interfaceData.RETURNS) {
+            for (const ret of interfaceData.RETURNS) {
+                if (ret.RETURNTYPE) {
+                    const structNames = extractAllStructNames(ret.RETURNTYPE);
+                    for (const structName of structNames) {
+                        if (structName)
+                            structRefs.add(structName);
+                    }
+                }
+            }
+        }
+    }
+    // Recursively collect all required structs and their dependencies
+    for (const structName of structRefs) {
+        collectStructRecursively(structName, allStructs, requiredStructs, processedStructs);
+    }
+    return requiredStructs;
+}
+/**
+ * Recursively collects a struct and all its nested struct dependencies
+ */
+function collectStructRecursively(structName, allStructs, requiredStructs, processedStructs) {
+    if (processedStructs.has(structName)) {
+        return; // Already processed
+    }
+    processedStructs.add(structName);
+    if (!allStructs[structName]) {
+        console.warn(`Struct ${structName} not found in STRUCTS section`);
+        return;
+    }
+    // Add the struct
+    requiredStructs[structName] = allStructs[structName];
+    // Check for nested struct references
+    const structFields = allStructs[structName];
+    if (Array.isArray(structFields)) {
+        for (const field of structFields) {
+            if (field.type) {
+                // Handle STRUCT(SomeStruct) and []STRUCT(SomeStruct)
+                const nestedStructNames = extractAllStructNames(field.type);
+                for (const nestedStructName of nestedStructNames) {
+                    if (nestedStructName) {
+                        collectStructRecursively(nestedStructName, allStructs, requiredStructs, processedStructs);
+                    }
+                }
+            }
+        }
+    }
+}
+/**
+ * Extracts all struct names from a type string, e.g. STRUCT(SomeStruct), []STRUCT(SomeStruct)
+ */
+function extractAllStructNames(typeString) {
+    const matches = [];
+    // Match STRUCT(SomeStruct)
+    const match1 = typeString.match(/^STRUCT\(([^)]+)\)/);
+    if (match1)
+        matches.push(match1[1]);
+    // Match []STRUCT(SomeStruct)
+    const match2 = typeString.match(/^\[\]STRUCT\(([^)]+)\)/);
+    if (match2)
+        matches.push(match2[1]);
+    return matches;
+}
+/**
+ * Extracts struct name from STRUCT(name) format
+ */
+function extractStructName(typeString) {
+    const match = typeString.match(/^STRUCT\(([^)]+)\)/) || typeString.match(/^\[\]STRUCT\(([^)]+)\)/);
+    return match ? match[1] : null;
+}
+/**
+ * Generates a filename for the mini Wrekenfile
+ */
+function generateFilename(endpoint) {
+    // Clean the endpoint to create a valid filename
+    const cleanEndpoint = endpoint
+        .replace(/^\/+/, '') // Remove leading slashes
+        .replace(/\/+$/, '') // Remove trailing slashes
+        .replace(/[^a-zA-Z0-9-_]/g, '-') // Replace special chars with hyphens
+        .replace(/-+/g, '-') // Replace multiple hyphens with single
+        .replace(/^-|-$/g, ''); // Remove leading/trailing hyphens
+    return `mini-${cleanEndpoint}.yaml`;
+}
+/**
+ * Saves mini Wrekenfiles to disk (optional utility function)
+ */
+function saveMiniWrekenfiles(miniWrekenfiles, outputDir = './mini-wrekenfiles') {
+    // Create output directory if it doesn't exist
+    if (!fs.existsSync(outputDir)) {
+        fs.mkdirSync(outputDir, { recursive: true });
+    }
+    for (const miniFile of miniWrekenfiles) {
+        const filePath = `${outputDir}/${miniFile.metadata.filename}`;
+        fs.writeFileSync(filePath, miniFile.content);
+        console.log(`Saved: ${filePath}`);
+    }
+}
+// Only export the main functions at the end. 

package/dist/openapi-to-wreken.d.ts

@@ -0,0 +1,2 @@
+declare function generateWrekenfile(spec: any, baseDir: string): string;
+export { generateWrekenfile };