reqon-dsl 0.2.0 → 0.3.0

package/dist/mcp/server.js

@@ -0,0 +1,451 @@
+#!/usr/bin/env node
+/**
+ * Reqon MCP Server
+ *
+ * Exposes Reqon pipeline capabilities via the Model Context Protocol.
+ *
+ * Tools:
+ * - reqon.execute: Execute a mission from DSL source
+ * - reqon.execute_file: Execute a mission from a file/folder path
+ * - reqon.query_store: Query data from a named store
+ * - reqon.list_stores: List available stores
+ *
+ * Resources:
+ * - reqon://stores - List all stores
+ * - reqon://stores/{name} - Access store data
+ */
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, } from '@modelcontextprotocol/sdk/types.js';
+import { parse, execute, fromPath } from '../index.js';
+import { createStore, } from '../stores/index.js';
+// Global store registry for cross-execution access
+const storeRegistry = new Map();
+let serverConfig = {
+    workingDirectory: process.cwd(),
+    verbose: false,
+};
+/**
+ * Format execution result for MCP response
+ */
+function formatExecutionResult(result) {
+    const output = {
+        success: result.success,
+        duration: result.duration,
+        actionsRun: result.actionsRun,
+    };
+    if (result.errors && result.errors.length > 0) {
+        output.errors = result.errors.map((e) => ({
+            action: e.action,
+            step: e.step,
+            message: e.message,
+        }));
+    }
+    // Include store summaries
+    if (result.stores && result.stores.size > 0) {
+        output.stores = Array.from(result.stores.keys());
+    }
+    if (result.executionId) {
+        output.executionId = result.executionId;
+    }
+    return JSON.stringify(output, null, 2);
+}
+/**
+ * Create executor config
+ */
+function createExecutorConfig(options) {
+    return {
+        verbose: options?.verbose ?? serverConfig.verbose,
+        dryRun: options?.dryRun ?? false,
+    };
+}
+// Define available tools
+const tools = [
+    {
+        name: 'reqon.execute',
+        description: 'Execute a Reqon mission from DSL source code. Returns execution results including any stored data.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source: {
+                    type: 'string',
+                    description: 'Reqon DSL source code defining the mission',
+                },
+                verbose: {
+                    type: 'boolean',
+                    description: 'Enable verbose logging',
+                    default: false,
+                },
+                dryRun: {
+                    type: 'boolean',
+                    description: 'Validate without executing HTTP requests',
+                    default: false,
+                },
+            },
+            required: ['source'],
+        },
+    },
+    {
+        name: 'reqon.execute_file',
+        description: 'Execute a Reqon mission from a file or folder path. Supports both single .reqon files and mission folders.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                path: {
+                    type: 'string',
+                    description: 'Path to .reqon file or mission folder (relative to working directory)',
+                },
+                verbose: {
+                    type: 'boolean',
+                    description: 'Enable verbose logging',
+                    default: false,
+                },
+                dryRun: {
+                    type: 'boolean',
+                    description: 'Validate without executing HTTP requests',
+                    default: false,
+                },
+            },
+            required: ['path'],
+        },
+    },
+    {
+        name: 'reqon.parse',
+        description: 'Parse Reqon DSL source and return the AST structure. Useful for validation without execution.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                source: {
+                    type: 'string',
+                    description: 'Reqon DSL source code to parse',
+                },
+            },
+            required: ['source'],
+        },
+    },
+    {
+        name: 'reqon.query_store',
+        description: 'Query data from a registered Reqon store. Returns matching records.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                store: {
+                    type: 'string',
+                    description: 'Name of the store to query',
+                },
+                filter: {
+                    type: 'object',
+                    description: 'Filter criteria',
+                    properties: {
+                        where: {
+                            type: 'object',
+                            description: 'Field equality conditions',
+                        },
+                        limit: {
+                            type: 'number',
+                            description: 'Maximum records to return',
+                        },
+                        offset: {
+                            type: 'number',
+                            description: 'Number of records to skip',
+                        },
+                    },
+                },
+            },
+            required: ['store'],
+        },
+    },
+    {
+        name: 'reqon.list_stores',
+        description: 'List all registered stores and their record counts.',
+        inputSchema: {
+            type: 'object',
+            properties: {},
+        },
+    },
+    {
+        name: 'reqon.register_store',
+        description: 'Register a store for use across executions. Stores persist in memory during the server session.',
+        inputSchema: {
+            type: 'object',
+            properties: {
+                name: {
+                    type: 'string',
+                    description: 'Store name for reference',
+                },
+                type: {
+                    type: 'string',
+                    enum: ['memory', 'file'],
+                    description: 'Store type',
+                    default: 'memory',
+                },
+                path: {
+                    type: 'string',
+                    description: 'File path for file-based stores',
+                },
+            },
+            required: ['name'],
+        },
+    },
+];
+// Create server instance
+const server = new Server({
+    name: 'reqon-mcp-server',
+    version: '0.1.0',
+}, {
+    capabilities: {
+        tools: {},
+        resources: {},
+    },
+});
+// Handle tool listing
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return { tools };
+});
+// Handle tool execution
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+        switch (name) {
+            case 'reqon.execute': {
+                const { source, verbose, dryRun } = args;
+                const config = createExecutorConfig({ verbose, dryRun });
+                const result = await execute(source, config);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: formatExecutionResult(result),
+                        },
+                    ],
+                };
+            }
+            case 'reqon.execute_file': {
+                const { path, verbose, dryRun } = args;
+                const config = createExecutorConfig({ verbose, dryRun });
+                const result = await fromPath(path, config);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: formatExecutionResult(result),
+                        },
+                    ],
+                };
+            }
+            case 'reqon.parse': {
+                const { source } = args;
+                const program = parse(source);
+                // Summarize AST for readability
+                const summary = {
+                    type: 'ReqonProgram',
+                    statements: program.statements.length,
+                    missions: program.statements
+                        .filter((s) => s.type === 'MissionDefinition')
+                        .map((m) => ({
+                        name: m.name,
+                        sources: m.sources?.length ?? 0,
+                        stores: m.stores?.length ?? 0,
+                        actions: m.actions?.length ?? 0,
+                        hasSchedule: !!m.schedule,
+                    })),
+                };
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify(summary, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'reqon.query_store': {
+                const { store: storeName, filter } = args;
+                const store = storeRegistry.get(storeName);
+                if (!store) {
+                    return {
+                        isError: true,
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Store "${storeName}" not found. Available stores: ${Array.from(storeRegistry.keys()).join(', ') || '(none)'}`,
+                            },
+                        ],
+                    };
+                }
+                const records = await store.list(filter);
+                const count = await store.count(filter);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                store: storeName,
+                                totalMatching: count,
+                                returned: records.length,
+                                data: records,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'reqon.list_stores': {
+                const stores = [];
+                for (const [name, store] of storeRegistry) {
+                    const count = await store.count();
+                    stores.push({ name, count });
+                }
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: JSON.stringify({
+                                stores,
+                                total: stores.length,
+                            }, null, 2),
+                        },
+                    ],
+                };
+            }
+            case 'reqon.register_store': {
+                const { name, type = 'memory', path } = args;
+                if (storeRegistry.has(name)) {
+                    return {
+                        content: [
+                            {
+                                type: 'text',
+                                text: `Store "${name}" already registered`,
+                            },
+                        ],
+                    };
+                }
+                const store = createStore({
+                    type,
+                    name,
+                    baseDir: path ?? '.reqon-data',
+                });
+                storeRegistry.set(name, store);
+                return {
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Store "${name}" registered (type: ${type})`,
+                        },
+                    ],
+                };
+            }
+            default:
+                return {
+                    isError: true,
+                    content: [
+                        {
+                            type: 'text',
+                            text: `Unknown tool: ${name}`,
+                        },
+                    ],
+                };
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        return {
+            isError: true,
+            content: [
+                {
+                    type: 'text',
+                    text: `Error: ${message}`,
+                },
+            ],
+        };
+    }
+});
+// Handle resource listing
+server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    const resources = [
+        {
+            uri: 'reqon://stores',
+            name: 'Reqon Stores',
+            description: 'List of all registered data stores',
+            mimeType: 'application/json',
+        },
+    ];
+    // Add individual store resources
+    for (const name of storeRegistry.keys()) {
+        resources.push({
+            uri: `reqon://stores/${name}`,
+            name: `Store: ${name}`,
+            description: `Data from the "${name}" store`,
+            mimeType: 'application/json',
+        });
+    }
+    return { resources };
+});
+// Handle resource reading
+server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const { uri } = request.params;
+    if (uri === 'reqon://stores') {
+        const stores = [];
+        for (const [name, store] of storeRegistry) {
+            const count = await store.count();
+            stores.push({ name, count });
+        }
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: 'application/json',
+                    text: JSON.stringify(stores, null, 2),
+                },
+            ],
+        };
+    }
+    const storeMatch = uri.match(/^reqon:\/\/stores\/(.+)$/);
+    if (storeMatch) {
+        const storeName = storeMatch[1];
+        const store = storeRegistry.get(storeName);
+        if (!store) {
+            throw new Error(`Store "${storeName}" not found`);
+        }
+        const records = await store.list({ limit: 100 });
+        const count = await store.count();
+        return {
+            contents: [
+                {
+                    uri,
+                    mimeType: 'application/json',
+                    text: JSON.stringify({
+                        store: storeName,
+                        totalRecords: count,
+                        data: records,
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    throw new Error(`Resource not found: ${uri}`);
+});
+// Start server
+async function main() {
+    // Parse CLI arguments
+    const args = process.argv.slice(2);
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === '--verbose' || args[i] === '-v') {
+            serverConfig.verbose = true;
+        }
+        if (args[i] === '--cwd' && args[i + 1]) {
+            serverConfig.workingDirectory = args[++i];
+            process.chdir(serverConfig.workingDirectory);
+        }
+    }
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    // Log to stderr so it doesn't interfere with MCP protocol on stdout
+    console.error('Reqon MCP Server running on stdio');
+    if (serverConfig.verbose) {
+        console.error(`  Working directory: ${serverConfig.workingDirectory}`);
+    }
+}
+main().catch((error) => {
+    console.error('Server error:', error);
+    process.exit(1);
+});

package/dist/oas/index.d.ts

@@ -2,3 +2,5 @@ export { loadOAS, resolveOperation, getResponseSchema, clearCache } from './load
 export type { OASSource, OASOperation, OpenAPISpec } from './loader.js';
 export { validateResponse } from './validator.js';
 export type { ValidationResult, ValidationError } from './validator.js';
+export { generateMockData } from './mock-generator.js';
+export type { MockGeneratorOptions } from './mock-generator.js';

package/dist/oas/index.js

@@ -1,2 +1,3 @@
 export { loadOAS, resolveOperation, getResponseSchema, clearCache } from './loader.js';
 export { validateResponse } from './validator.js';
+export { generateMockData } from './mock-generator.js';

package/dist/oas/mock-generator.d.ts

@@ -0,0 +1,12 @@
+import type { OpenAPIV3 } from 'openapi-types';
+/**
+ * Generate mock data from an OpenAPI schema.
+ * Used for dry-run mode to produce realistic mock responses.
+ */
+export declare function generateMockData(schema: OpenAPIV3.SchemaObject, options?: MockGeneratorOptions): unknown;
+export interface MockGeneratorOptions {
+    /** Maximum depth for nested objects (default: 3) */
+    maxDepth?: number;
+    /** Number of items to generate for arrays (default: 2) */
+    arrayLength?: number;
+}

package/dist/oas/mock-generator.js

@@ -0,0 +1,187 @@
+/**
+ * Generate mock data from an OpenAPI schema.
+ * Used for dry-run mode to produce realistic mock responses.
+ */
+export function generateMockData(schema, options = {}) {
+    const ctx = {
+        depth: 0,
+        maxDepth: options.maxDepth ?? 3,
+        arrayLength: options.arrayLength ?? 2,
+        seenRefs: new Set(),
+        counter: { value: 0 },
+    };
+    return generateValue(schema, ctx);
+}
+function generateValue(schema, ctx) {
+    // Handle nullable - only return null if explicitly marked nullable
+    // and we're past the top level (depth > 0). Use strict equality check
+    // to avoid false positives from undefined/truthy coercion.
+    if (schema.nullable === true && ctx.depth > 1) {
+        // Return null ~20% of the time for nullable fields deep in the tree
+        if (Math.random() < 0.2) {
+            return null;
+        }
+    }
+    // Handle enum - pick first value
+    if (schema.enum && schema.enum.length > 0) {
+        return schema.enum[0];
+    }
+    // Handle example if provided
+    if (schema.example !== undefined) {
+        return schema.example;
+    }
+    // Handle default if provided
+    if (schema.default !== undefined) {
+        return schema.default;
+    }
+    // Check for allOf/oneOf/anyOf
+    if (schema.allOf && schema.allOf.length > 0) {
+        // Merge all schemas
+        const merged = {};
+        for (const subSchema of schema.allOf) {
+            const subValue = generateValue(subSchema, ctx);
+            if (typeof subValue === 'object' && subValue !== null) {
+                Object.assign(merged, subValue);
+            }
+        }
+        return merged;
+    }
+    if (schema.oneOf && schema.oneOf.length > 0) {
+        return generateValue(schema.oneOf[0], ctx);
+    }
+    if (schema.anyOf && schema.anyOf.length > 0) {
+        return generateValue(schema.anyOf[0], ctx);
+    }
+    // Generate based on type
+    switch (schema.type) {
+        case 'string':
+            return generateString(schema, ctx);
+        case 'number':
+            return generateNumber(schema);
+        case 'integer':
+            return generateInteger(schema);
+        case 'boolean':
+            return true;
+        case 'array':
+            return generateArray(schema, ctx);
+        case 'object':
+            return generateObject(schema, ctx);
+        default: {
+            // No type specified - try to infer from properties
+            // Cast to SchemaObject to access properties on untyped schemas
+            const untyped = schema;
+            if (untyped.properties) {
+                return generateObject(untyped, ctx);
+            }
+            // Return empty object as fallback
+            return {};
+        }
+    }
+}
+function generateString(schema, ctx) {
+    // Handle format
+    switch (schema.format) {
+        case 'date':
+            return '2024-01-15';
+        case 'date-time':
+            return '2024-01-15T10:30:00Z';
+        case 'email':
+            return `user${ctx.counter.value++}@example.com`;
+        case 'uri':
+        case 'url':
+            return 'https://example.com';
+        case 'uuid': {
+            // Generate unique UUIDs using counter
+            const id = ctx.counter.value++;
+            const hex = id.toString(16).padStart(12, '0');
+            return `550e8400-e29b-41d4-a716-${hex}`;
+        }
+        case 'hostname':
+            return 'example.com';
+        case 'ipv4':
+            return '192.168.1.1';
+        case 'ipv6':
+            return '2001:0db8:85a3:0000:0000:8a2e:0370:7334';
+        case 'byte':
+            return 'SGVsbG8gV29ybGQ='; // Base64 encoded "Hello World"
+        case 'binary':
+            return '<binary>';
+        case 'password':
+            return '********';
+        case 'phone':
+            return '+1-555-555-5555';
+    }
+    // Respect minLength/maxLength
+    const minLen = schema.minLength ?? 0;
+    const maxLen = schema.maxLength ?? 50;
+    const targetLen = Math.max(minLen, Math.min(8, maxLen));
+    // Generate a simple mock string
+    const base = 'mock_value';
+    if (base.length >= targetLen) {
+        return base.substring(0, targetLen);
+    }
+    return base.padEnd(targetLen, '_');
+}
+function generateNumber(schema) {
+    const min = schema.minimum ?? 0;
+    const max = schema.maximum ?? 100;
+    // Generate a value in range
+    const value = min + (max - min) / 2;
+    // Handle multipleOf
+    if (schema.multipleOf) {
+        return Math.round(value / schema.multipleOf) * schema.multipleOf;
+    }
+    return Math.round(value * 100) / 100;
+}
+function generateInteger(schema) {
+    const min = schema.minimum ?? 0;
+    const max = schema.maximum ?? 100;
+    // Generate integer in range
+    const value = Math.floor(min + (max - min) / 2);
+    // Handle multipleOf
+    if (schema.multipleOf) {
+        return Math.round(value / schema.multipleOf) * schema.multipleOf;
+    }
+    return value;
+}
+function generateArray(schema, ctx) {
+    // Check depth limit
+    if (ctx.depth >= ctx.maxDepth) {
+        return [];
+    }
+    // Determine array length
+    const minItems = schema.minItems ?? 0;
+    const maxItems = schema.maxItems ?? ctx.arrayLength;
+    const length = Math.max(minItems, Math.min(ctx.arrayLength, maxItems));
+    if (!schema.items) {
+        return Array(length).fill({});
+    }
+    const itemSchema = schema.items;
+    const items = [];
+    for (let i = 0; i < length; i++) {
+        items.push(generateValue(itemSchema, {
+            ...ctx,
+            depth: ctx.depth + 1,
+        }));
+    }
+    return items;
+}
+function generateObject(schema, ctx) {
+    // Check depth limit
+    if (ctx.depth >= ctx.maxDepth) {
+        return {};
+    }
+    const result = {};
+    const properties = schema.properties;
+    if (!properties) {
+        return result;
+    }
+    // Include all properties at any depth to generate complete mock data
+    for (const [key, propSchema] of Object.entries(properties)) {
+        result[key] = generateValue(propSchema, {
+            ...ctx,
+            depth: ctx.depth + 1,
+        });
+    }
+    return result;
+}