@stackkedjohn/mcp-factory-cli 0.1.0

package/dist/parsers/openapi.js

@@ -0,0 +1,205 @@
+/**
+ * Parse OpenAPI 3.x or Swagger 2.0 specification into unified APISchema
+ */
+export function parseOpenAPI(spec) {
+    const isSwagger2 = spec.swagger === '2.0';
+    const isOpenAPI3 = spec.openapi?.startsWith('3.');
+    if (!isSwagger2 && !isOpenAPI3) {
+        throw new Error('Unsupported spec version. Only OpenAPI 3.x and Swagger 2.0 are supported.');
+    }
+    return {
+        name: spec.info.title || 'API',
+        baseUrl: getBaseUrl(spec),
+        auth: detectAuth(spec),
+        endpoints: parseEndpoints(spec),
+    };
+}
+/**
+ * Extract base URL from spec
+ */
+function getBaseUrl(spec) {
+    // OpenAPI 3.x
+    if (spec.servers && spec.servers.length > 0) {
+        return spec.servers[0].url;
+    }
+    // Swagger 2.0
+    if (spec.host) {
+        const scheme = spec.schemes?.[0] || 'https';
+        const basePath = spec.basePath || '';
+        return `${scheme}://${spec.host}${basePath}`;
+    }
+    return '';
+}
+/**
+ * Detect authentication configuration
+ */
+function detectAuth(spec) {
+    const securitySchemes = spec.components?.securitySchemes || spec.securityDefinitions || {};
+    const firstScheme = Object.values(securitySchemes)[0];
+    if (!firstScheme) {
+        return { type: 'none' };
+    }
+    switch (firstScheme.type) {
+        case 'apiKey':
+            return {
+                type: 'api-key',
+                location: firstScheme.in === 'header' ? 'header' : 'query',
+                name: firstScheme.name,
+                description: firstScheme.description,
+            };
+        case 'http':
+            if (firstScheme.scheme === 'bearer') {
+                return { type: 'bearer', description: firstScheme.description };
+            }
+            if (firstScheme.scheme === 'basic') {
+                return { type: 'basic', description: firstScheme.description };
+            }
+            return { type: 'none' };
+        case 'oauth2':
+            return { type: 'oauth', description: firstScheme.description };
+        default:
+            return { type: 'none' };
+    }
+}
+/**
+ * Parse all endpoints from spec
+ */
+function parseEndpoints(spec) {
+    const endpoints = [];
+    const paths = spec.paths || {};
+    for (const [path, pathItem] of Object.entries(paths)) {
+        const methods = ['get', 'post', 'put', 'patch', 'delete', 'options', 'head'];
+        for (const method of methods) {
+            const operation = pathItem[method];
+            if (operation) {
+                endpoints.push(parseOperation(path, method, operation, pathItem));
+            }
+        }
+    }
+    return endpoints;
+}
+/**
+ * Parse a single operation into an Endpoint
+ */
+function parseOperation(path, method, operation, pathItem) {
+    const parameters = [];
+    // Parse path-level parameters
+    if (pathItem.parameters) {
+        parameters.push(...parseParameters(pathItem.parameters));
+    }
+    // Parse operation-level parameters
+    if (operation.parameters) {
+        parameters.push(...parseParameters(operation.parameters));
+    }
+    // Parse request body (OpenAPI 3.x)
+    let requestBody;
+    if (operation.requestBody) {
+        const content = operation.requestBody.content || {};
+        const jsonContent = content['application/json'];
+        if (jsonContent?.schema) {
+            requestBody = {
+                description: operation.requestBody.description || '',
+                required: operation.requestBody.required || false,
+                contentType: 'application/json',
+                schema: parseSchema(jsonContent.schema),
+            };
+        }
+    }
+    // Parse response (use first successful response)
+    const responses = operation.responses || {};
+    const successCode = Object.keys(responses).find(code => code.startsWith('2')) || '200';
+    const successResponse = responses[successCode] || {};
+    const responseContent = successResponse.content?.['application/json'];
+    const response = {
+        statusCode: parseInt(successCode),
+        description: successResponse.description || '',
+        contentType: 'application/json',
+        schema: responseContent?.schema ? parseSchema(responseContent.schema) : { type: 'object' },
+    };
+    // Parse error responses
+    const errors = [];
+    for (const [code, resp] of Object.entries(responses)) {
+        if (!code.startsWith('2') && code !== 'default') {
+            const errorResp = resp;
+            const errorContent = errorResp.content?.['application/json'];
+            errors.push({
+                statusCode: parseInt(code),
+                description: errorResp.description || `Error ${code}`,
+                schema: errorContent?.schema ? parseSchema(errorContent.schema) : undefined,
+            });
+        }
+    }
+    return {
+        id: operation.operationId || `${method}_${path.replace(/\//g, '_')}`,
+        method: method.toUpperCase(),
+        path,
+        description: operation.description || operation.summary || '',
+        parameters,
+        requestBody,
+        response,
+        errors,
+    };
+}
+/**
+ * Parse parameters array
+ */
+function parseParameters(params) {
+    return params.map((param) => {
+        // Handle $ref
+        if (param.$ref) {
+            // For simplicity, we'll skip resolving refs
+            return null;
+        }
+        // Only parse path, query, and header parameters (not body)
+        if (!['path', 'query', 'header'].includes(param.in)) {
+            return null;
+        }
+        const schema = param.schema || { type: param.type };
+        return {
+            name: param.name,
+            in: param.in,
+            required: param.required || false,
+            description: param.description || '',
+            schema: parseSchema(schema),
+        };
+    }).filter(Boolean);
+}
+/**
+ * Parse JSON Schema into SchemaType
+ */
+function parseSchema(schema) {
+    if (!schema) {
+        return { type: 'string' };
+    }
+    // Handle basic types
+    if (schema.type === 'object' || schema.properties) {
+        const properties = {};
+        const required = schema.required || [];
+        for (const [key, value] of Object.entries(schema.properties || {})) {
+            properties[key] = parseSchema(value);
+        }
+        return {
+            type: 'object',
+            properties,
+            required,
+        };
+    }
+    if (schema.type === 'array') {
+        return {
+            type: 'array',
+            items: parseSchema(schema.items),
+        };
+    }
+    // Enum
+    if (schema.enum) {
+        return {
+            type: schema.type || 'string',
+            enum: schema.enum,
+        };
+    }
+    // Basic types with format
+    return {
+        type: schema.type || 'string',
+        format: schema.format,
+    };
+}

package/dist/parsers/postman.d.ts

@@ -0,0 +1,2 @@
+import { APISchema } from '../schema/api-schema.js';
+export declare function parsePostman(collection: any): APISchema;

package/dist/parsers/postman.js

@@ -0,0 +1,4 @@
+import { ParseError } from '../utils/errors.js';
+export function parsePostman(collection) {
+    throw new ParseError('Postman collection parsing not yet implemented');
+}

package/dist/registry/manager.d.ts

@@ -0,0 +1,13 @@
+export interface RegistryEntry {
+    name: string;
+    path: string;
+    createdAt: string;
+}
+export interface Registry {
+    servers: RegistryEntry[];
+}
+export declare function loadRegistry(): Promise<Registry>;
+export declare function saveRegistry(registry: Registry): Promise<void>;
+export declare function addServer(name: string, serverPath: string): Promise<void>;
+export declare function getServer(name: string): Promise<RegistryEntry | undefined>;
+export declare function listServers(): Promise<RegistryEntry[]>;

package/dist/registry/manager.js

@@ -0,0 +1,43 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+const REGISTRY_DIR = path.join(os.homedir(), '.mcp-factory');
+const REGISTRY_FILE = path.join(REGISTRY_DIR, 'registry.json');
+async function ensureRegistry() {
+    try {
+        await fs.access(REGISTRY_FILE);
+    }
+    catch {
+        await fs.mkdir(REGISTRY_DIR, { recursive: true });
+        await fs.writeFile(REGISTRY_FILE, JSON.stringify({ servers: [] }, null, 2));
+    }
+}
+export async function loadRegistry() {
+    await ensureRegistry();
+    const content = await fs.readFile(REGISTRY_FILE, 'utf-8');
+    return JSON.parse(content);
+}
+export async function saveRegistry(registry) {
+    await ensureRegistry();
+    await fs.writeFile(REGISTRY_FILE, JSON.stringify(registry, null, 2));
+}
+export async function addServer(name, serverPath) {
+    const registry = await loadRegistry();
+    // Remove existing entry if present
+    registry.servers = registry.servers.filter(s => s.name !== name);
+    // Add new entry
+    registry.servers.push({
+        name,
+        path: path.resolve(serverPath),
+        createdAt: new Date().toISOString(),
+    });
+    await saveRegistry(registry);
+}
+export async function getServer(name) {
+    const registry = await loadRegistry();
+    return registry.servers.find(s => s.name === name);
+}
+export async function listServers() {
+    const registry = await loadRegistry();
+    return registry.servers;
+}

package/dist/schema/api-schema.d.ts

@@ -0,0 +1,77 @@
+export interface APISchema {
+    name: string;
+    baseUrl: string;
+    auth: AuthConfig;
+    endpoints: Endpoint[];
+    commonHeaders?: Record<string, string>;
+    rateLimit?: RateLimitConfig;
+    pagination?: PaginationConfig;
+}
+export interface AuthConfig {
+    type: 'api-key' | 'bearer' | 'oauth' | 'basic' | 'none';
+    location?: 'header' | 'query';
+    name?: string;
+    description?: string;
+}
+export interface Endpoint {
+    id: string;
+    method: 'GET' | 'POST' | 'PUT' | 'PATCH' | 'DELETE';
+    path: string;
+    description: string;
+    parameters: Parameter[];
+    requestBody?: RequestBody;
+    response: ResponseSchema;
+    errors: ErrorSchema[];
+}
+export interface Parameter {
+    name: string;
+    in: 'path' | 'query' | 'header';
+    description?: string;
+    required: boolean;
+    schema: SchemaType;
+}
+export interface RequestBody {
+    description?: string;
+    required: boolean;
+    contentType: string;
+    schema: SchemaType;
+}
+export interface ResponseSchema {
+    statusCode: number;
+    description?: string;
+    contentType: string;
+    schema: SchemaType;
+}
+export interface ErrorSchema {
+    statusCode: number;
+    description: string;
+    schema?: SchemaType;
+}
+export interface SchemaType {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    properties?: Record<string, SchemaType>;
+    items?: SchemaType;
+    required?: string[];
+    enum?: string[];
+    format?: string;
+}
+export interface RateLimitConfig {
+    strategy: 'header-based' | 'retry-after' | 'none';
+    headerName?: string;
+    requestsPerWindow?: number;
+    windowSeconds?: number;
+}
+export interface PaginationConfig {
+    style: 'cursor' | 'offset' | 'page' | 'link-header';
+    cursorParam?: string;
+    limitParam?: string;
+    offsetParam?: string;
+    pageParam?: string;
+}
+export interface DetectedPatterns {
+    authPattern: 'api-key' | 'bearer' | 'oauth' | 'basic' | 'none';
+    paginationStyle?: 'cursor' | 'offset' | 'page' | 'link-header';
+    rateLimitStrategy?: 'header-based' | 'retry-after' | 'none';
+    errorFormat: 'standard' | 'custom';
+    hasWebhooks: boolean;
+}

package/dist/schema/api-schema.js

@@ -0,0 +1 @@
+export {};

package/dist/utils/errors.d.ts

@@ -0,0 +1,13 @@
+export declare class MCPFactoryError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}
+export declare class ParseError extends MCPFactoryError {
+    constructor(message: string);
+}
+export declare class ValidationError extends MCPFactoryError {
+    constructor(message: string);
+}
+export declare class GenerationError extends MCPFactoryError {
+    constructor(message: string);
+}

package/dist/utils/errors.js

@@ -0,0 +1,26 @@
+export class MCPFactoryError extends Error {
+    code;
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+        this.name = 'MCPFactoryError';
+    }
+}
+export class ParseError extends MCPFactoryError {
+    constructor(message) {
+        super(message, 'PARSE_ERROR');
+        this.name = 'ParseError';
+    }
+}
+export class ValidationError extends MCPFactoryError {
+    constructor(message) {
+        super(message, 'VALIDATION_ERROR');
+        this.name = 'ValidationError';
+    }
+}
+export class GenerationError extends MCPFactoryError {
+    constructor(message) {
+        super(message, 'GENERATION_ERROR');
+        this.name = 'GenerationError';
+    }
+}

package/dist/utils/logger.d.ts

@@ -0,0 +1,7 @@
+export declare const logger: {
+    info: (message: string) => void;
+    success: (message: string) => void;
+    error: (message: string) => void;
+    warn: (message: string) => void;
+    debug: (message: string) => void;
+};

package/dist/utils/logger.js

@@ -0,0 +1,19 @@
+export const logger = {
+    info: (message) => {
+        console.log(`ℹ ${message}`);
+    },
+    success: (message) => {
+        console.log(`✓ ${message}`);
+    },
+    error: (message) => {
+        console.error(`✗ ${message}`);
+    },
+    warn: (message) => {
+        console.warn(`⚠ ${message}`);
+    },
+    debug: (message) => {
+        if (process.env.DEBUG) {
+            console.log(`[DEBUG] ${message}`);
+        }
+    }
+};