mcpmake 0.1.0

package/dist/commands/diff.js

@@ -0,0 +1,185 @@
+import { defineCommand } from 'citty';
+import { loadOpenApiSpec } from '../parser/openapi-loader.js';
+import { extractOperations } from '../parser/operation-extractor.js';
+import { buildAllTools } from '../transformer/tool-builder.js';
+import { logger } from '../utils/logger.js';
+function diffTools(oldTools, newTools) {
+    const oldByName = new Map(oldTools.map((t) => [t.name, t]));
+    const newByName = new Map(newTools.map((t) => [t.name, t]));
+    const added = [];
+    const removed = [];
+    const changed = [];
+    let unchanged = 0;
+    // Find removed and changed
+    for (const [name, oldTool] of oldByName) {
+        const newTool = newByName.get(name);
+        if (!newTool) {
+            removed.push(oldTool);
+            continue;
+        }
+        const changes = [];
+        if (oldTool.method !== newTool.method) {
+            changes.push({
+                field: 'method',
+                old: oldTool.method.toUpperCase(),
+                new: newTool.method.toUpperCase(),
+            });
+        }
+        if (oldTool.pathTemplate !== newTool.pathTemplate) {
+            changes.push({
+                field: 'path',
+                old: oldTool.pathTemplate,
+                new: newTool.pathTemplate,
+            });
+        }
+        if (oldTool.description !== newTool.description) {
+            changes.push({
+                field: 'description',
+                old: oldTool.description.slice(0, 80) + (oldTool.description.length > 80 ? '...' : ''),
+                new: newTool.description.slice(0, 80) + (newTool.description.length > 80 ? '...' : ''),
+            });
+        }
+        // Compare parameters
+        const oldParams = new Set([
+            ...oldTool.pathParams,
+            ...oldTool.queryParams,
+            ...oldTool.headerParams,
+        ]);
+        const newParams = new Set([
+            ...newTool.pathParams,
+            ...newTool.queryParams,
+            ...newTool.headerParams,
+        ]);
+        const addedParams = [...newParams].filter((p) => !oldParams.has(p));
+        const removedParams = [...oldParams].filter((p) => !newParams.has(p));
+        if (addedParams.length > 0) {
+            changes.push({
+                field: 'parameters (added)',
+                old: '',
+                new: addedParams.join(', '),
+            });
+        }
+        if (removedParams.length > 0) {
+            changes.push({
+                field: 'parameters (removed)',
+                old: removedParams.join(', '),
+                new: '',
+            });
+        }
+        if (oldTool.hasRequestBody !== newTool.hasRequestBody) {
+            changes.push({
+                field: 'request body',
+                old: oldTool.hasRequestBody ? 'present' : 'absent',
+                new: newTool.hasRequestBody ? 'present' : 'absent',
+            });
+        }
+        if (changes.length > 0) {
+            changed.push({ tool: newTool, changes });
+        }
+        else {
+            unchanged++;
+        }
+    }
+    // Find added
+    for (const [name, newTool] of newByName) {
+        if (!oldByName.has(name)) {
+            added.push(newTool);
+        }
+    }
+    return { added, removed, changed, unchanged };
+}
+// Simple ANSI color helpers
+const green = (s) => `\x1b[32m${s}\x1b[0m`;
+const red = (s) => `\x1b[31m${s}\x1b[0m`;
+const yellow = (s) => `\x1b[33m${s}\x1b[0m`;
+const dim = (s) => `\x1b[2m${s}\x1b[0m`;
+export default defineCommand({
+    meta: {
+        name: 'diff',
+        description: 'Compare tools generated from two OpenAPI specs',
+    },
+    args: {
+        oldSpec: {
+            type: 'positional',
+            description: 'Path or URL to the old OpenAPI spec',
+            required: true,
+        },
+        newSpec: {
+            type: 'positional',
+            description: 'Path or URL to the new OpenAPI spec',
+            required: true,
+        },
+        format: {
+            type: 'string',
+            description: 'Output format: "text" (default) or "json"',
+            default: 'text',
+        },
+    },
+    async run({ args }) {
+        const oldSpec = args.oldSpec;
+        const newSpec = args.newSpec;
+        logger.info(`Comparing specs...`);
+        logger.info(`  Old: ${oldSpec}`);
+        logger.info(`  New: ${newSpec}`);
+        const [oldLoad, newLoad] = await Promise.all([
+            loadOpenApiSpec(oldSpec),
+            loadOpenApiSpec(newSpec),
+        ]);
+        const oldOps = extractOperations(oldLoad.api);
+        const newOps = extractOperations(newLoad.api);
+        const oldTools = buildAllTools(oldOps.operations);
+        const newTools = buildAllTools(newOps.operations);
+        const result = diffTools(oldTools, newTools);
+        if (args.format === 'json') {
+            console.log(JSON.stringify({
+                added: result.added.map((t) => t.name),
+                removed: result.removed.map((t) => t.name),
+                changed: result.changed.map((c) => ({
+                    tool: c.tool.name,
+                    changes: c.changes,
+                })),
+                unchanged: result.unchanged,
+            }, null, 2));
+            return;
+        }
+        console.log('');
+        // Added
+        if (result.added.length > 0) {
+            console.log(green(`+ ${result.added.length} added tool(s):`));
+            for (const tool of result.added) {
+                console.log(green(`  + ${tool.name}`) + dim(` (${tool.method.toUpperCase()} ${tool.pathTemplate})`));
+            }
+            console.log('');
+        }
+        // Removed
+        if (result.removed.length > 0) {
+            console.log(red(`- ${result.removed.length} removed tool(s):`));
+            for (const tool of result.removed) {
+                console.log(red(`  - ${tool.name}`) + dim(` (${tool.method.toUpperCase()} ${tool.pathTemplate})`));
+            }
+            console.log('');
+        }
+        // Changed
+        if (result.changed.length > 0) {
+            console.log(yellow(`~ ${result.changed.length} changed tool(s):`));
+            for (const { tool, changes } of result.changed) {
+                console.log(yellow(`  ~ ${tool.name}`));
+                for (const change of changes) {
+                    if (change.old && change.new) {
+                        console.log(`      ${change.field}: ${red(change.old)} -> ${green(change.new)}`);
+                    }
+                    else if (change.new) {
+                        console.log(`      ${change.field}: ${green(change.new)}`);
+                    }
+                    else {
+                        console.log(`      ${change.field}: ${red(change.old)}`);
+                    }
+                }
+            }
+            console.log('');
+        }
+        // Summary
+        const total = result.added.length + result.removed.length + result.changed.length + result.unchanged;
+        console.log(`Summary: ${total} tools total — ${green(`${result.added.length} added`)}, ${red(`${result.removed.length} removed`)}, ${yellow(`${result.changed.length} changed`)}, ${result.unchanged} unchanged`);
+    },
+});

package/dist/commands/from/describe.d.ts

@@ -0,0 +1,65 @@
+declare const _default: import("citty").CommandDef<{
+    description: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    output: {
+        type: "string";
+        alias: string;
+        description: string;
+        required: true;
+    };
+    name: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    'base-url': {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    model: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    'save-spec': {
+        type: "string";
+        description: string;
+    };
+    transport: {
+        type: "string";
+        alias: string;
+        description: string;
+        default: string;
+    };
+    target: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    include: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    exclude: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    force: {
+        type: "boolean";
+        alias: string;
+        description: string;
+        default: false;
+    };
+    'dry-run': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+}>;
+export default _default;

package/dist/commands/from/describe.js

@@ -0,0 +1,173 @@
+import { defineConfigurableCommand } from '../../config/configurable-command.js';
+import { writeFile, mkdtemp, rm } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { tmpdir } from 'node:os';
+import { generateSpecFromDescription } from '../../generator/spec-generator.js';
+import { loadOpenApiSpec } from '../../parser/openapi-loader.js';
+import { extractOperations } from '../../parser/operation-extractor.js';
+import { detectAuthSchemes } from '../../transformer/auth-detector.js';
+import { buildAllTools } from '../../transformer/tool-builder.js';
+import { filterOperations } from '../../transformer/operation-filter.js';
+import { emitProject } from '../../emitter/index.js';
+import { targetArg, resolveTarget, resolveTransport, printWorkerNextSteps, } from './target-support.js';
+import { logger } from '../../utils/logger.js';
+import { fail } from '../../utils/fail.js';
+function toPackageName(title) {
+    return title
+        .toLowerCase()
+        .replace(/[^a-z0-9]+/g, '-')
+        .replace(/^-|-$/g, '');
+}
+export default defineConfigurableCommand('describe', {
+    meta: {
+        name: 'describe',
+        description: 'Generate an MCP server from a natural language description using AI',
+    },
+    args: {
+        description: {
+            type: 'positional',
+            description: 'Natural language description of the API (e.g., "manage GitHub issues")',
+            required: true,
+        },
+        output: {
+            type: 'string',
+            alias: 'o',
+            description: 'Output directory for generated project',
+            required: true,
+        },
+        name: {
+            type: 'string',
+            alias: 'n',
+            description: 'Server name',
+        },
+        'base-url': {
+            type: 'string',
+            alias: 'b',
+            description: 'Base URL for the API',
+        },
+        model: {
+            type: 'string',
+            alias: 'm',
+            description: 'Claude model to use (default: claude-sonnet-4-20250514)',
+        },
+        'save-spec': {
+            type: 'string',
+            description: 'Save the generated OpenAPI spec to this path',
+        },
+        transport: {
+            type: 'string',
+            alias: 't',
+            description: 'Transport mode: "stdio" (default) or "http"',
+            default: 'stdio',
+        },
+        target: targetArg,
+        include: {
+            type: 'string',
+            alias: 'i',
+            description: 'Only include operations matching these patterns (comma-separated)',
+        },
+        exclude: {
+            type: 'string',
+            alias: 'e',
+            description: 'Exclude operations matching these patterns (comma-separated)',
+        },
+        force: {
+            type: 'boolean',
+            alias: 'f',
+            description: 'Overwrite existing output directory',
+            default: false,
+        },
+        'dry-run': {
+            type: 'boolean',
+            description: 'Preview generated files without writing',
+            default: false,
+        },
+    },
+    async run({ args }) {
+        // Generate OpenAPI spec from description
+        const specJson = await generateSpecFromDescription({
+            description: args.description,
+            baseUrl: args['base-url'],
+            model: args.model,
+        });
+        // Save spec if requested
+        if (args['save-spec']) {
+            await writeFile(args['save-spec'], specJson, 'utf-8');
+            logger.info(`Saved generated spec to: ${args['save-spec']}`);
+        }
+        // Write spec to temp file and parse through the OpenAPI pipeline
+        const tempDir = await mkdtemp(resolve(tmpdir(), 'mcpmake-describe-'));
+        const tempSpecPath = resolve(tempDir, 'generated-spec.json');
+        try {
+            await writeFile(tempSpecPath, specJson, 'utf-8');
+            const { api } = await loadOpenApiSpec(tempSpecPath);
+            const { operations, baseUrl, securitySchemes, info } = extractOperations(api);
+            if (operations.length === 0) {
+                await fail('Generated spec has no operations. Try a more specific description.');
+            }
+            logger.info(`Generated ${operations.length} operations`);
+            const filtered = filterOperations(operations, {
+                include: args.include?.split(',').map((s) => s.trim()),
+                exclude: args.exclude?.split(',').map((s) => s.trim()),
+            });
+            if (filtered.length === 0) {
+                await fail('No operations left after filtering.');
+            }
+            if (filtered.length !== operations.length) {
+                logger.info(`${filtered.length} operations after filtering`);
+            }
+            const tools = buildAllTools(filtered);
+            const { authSchemes, envVars } = detectAuthSchemes(securitySchemes);
+            const serverName = args.name ?? toPackageName(info.title);
+            const resolvedBaseUrl = args['base-url'] ?? baseUrl;
+            const target = resolveTarget(args.target);
+            const transport = resolveTransport(target, args.transport);
+            const manifest = {
+                serverName,
+                serverVersion: info.version ?? '1.0.0',
+                baseUrl: resolvedBaseUrl || 'https://api.example.com',
+                transport,
+                tools,
+                authSchemes,
+                envVars: [
+                    {
+                        name: 'BASE_URL',
+                        description: 'API base URL',
+                        required: true,
+                        example: resolvedBaseUrl,
+                    },
+                    ...envVars,
+                ],
+                target,
+            };
+            logger.info(`Generating MCP server: ${serverName}` +
+                (target === 'cloudflare' ? ' (Cloudflare Workers)' : ''));
+            await emitProject(manifest, {
+                outputDir: args.output,
+                force: args.force ?? false,
+                dryRun: args['dry-run'] ?? false,
+            });
+            logger.success(`MCP server generated at: ${args.output}`);
+            logger.info('');
+            logger.info(`Tools generated: ${tools.length}`);
+            for (const tool of tools) {
+                logger.info(`  - ${tool.name}: ${tool.description}`);
+            }
+            if (target === 'cloudflare') {
+                printWorkerNextSteps(args.output);
+            }
+            else {
+                logger.info('');
+                logger.info('Next steps:');
+                logger.info(`  cd ${args.output}`);
+                logger.info('  cp .env.example .env  # fill in your credentials');
+                logger.info('  npm install');
+                logger.info('  npm run build');
+                logger.info('  npm start');
+            }
+        }
+        finally {
+            await rm(tempDir, { recursive: true, force: true });
+        }
+    },
+});

package/dist/commands/from/har.d.ts

@@ -0,0 +1,81 @@
+declare const _default: import("citty").CommandDef<{
+    file: {
+        type: "positional";
+        description: string;
+        required: true;
+    };
+    output: {
+        type: "string";
+        alias: string;
+        description: string;
+        required: true;
+    };
+    name: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    domain: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    'include-errors': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    'improve-names': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    dedup: {
+        type: "boolean";
+        description: string;
+        default: true;
+    };
+    interactive: {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    force: {
+        type: "boolean";
+        alias: string;
+        description: string;
+        default: false;
+    };
+    transport: {
+        type: "string";
+        alias: string;
+        description: string;
+        default: string;
+    };
+    include: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    exclude: {
+        type: "string";
+        alias: string;
+        description: string;
+    };
+    'dry-run': {
+        type: "boolean";
+        description: string;
+        default: false;
+    };
+    format: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+    target: {
+        type: "string";
+        description: string;
+        default: string;
+    };
+}>;
+export default _default;