mcpmake 0.1.1 → 0.2.1

package/dist/transformer/har-clusterer.d.ts

@@ -1,9 +0,0 @@
-import type { NormalizedEntry } from '../parser/har-normalizer.js';
-export interface EntryCluster {
-    signature: string;
-    method: string;
-    normalizedPath: string;
-    baseUrl: string;
-    entries: NormalizedEntry[];
-}
-export declare function clusterEntries(entries: NormalizedEntry[]): EntryCluster[];

package/dist/transformer/har-clusterer.js

@@ -1,27 +0,0 @@
-export function clusterEntries(entries) {
-    const groups = new Map();
-    for (const entry of entries) {
-        const method = entry.entry.request.method.toUpperCase();
-        const signature = `${method} ${entry.normalizedPath}`;
-        const existing = groups.get(signature);
-        if (existing) {
-            existing.push(entry);
-        }
-        else {
-            groups.set(signature, [entry]);
-        }
-    }
-    const clusters = [];
-    for (const [signature, clusterEntries] of groups) {
-        const [method, ...pathParts] = signature.split(' ');
-        const normalizedPath = pathParts.join(' ');
-        clusters.push({
-            signature,
-            method: method.toLowerCase(),
-            normalizedPath,
-            baseUrl: clusterEntries[0].baseUrl,
-            entries: clusterEntries,
-        });
-    }
-    return clusters;
-}

package/dist/transformer/har-dedup.d.ts

@@ -1,10 +0,0 @@
-import type { NormalizedEntry } from '../parser/har-normalizer.js';
-/**
- * Deduplicate HAR entries that are likely pagination or retries.
- *
- * Strategy:
- * - Group by method + normalizedPath (same as clustering)
- * - Within each group, detect pagination patterns (same URL with different page/offset/cursor params)
- * - Remove retries: consecutive requests to the same URL within 5s with same method
- */
-export declare function deduplicateEntries(entries: NormalizedEntry[]): NormalizedEntry[];

package/dist/transformer/har-dedup.js

@@ -1,81 +0,0 @@
-/**
- * Deduplicate HAR entries that are likely pagination or retries.
- *
- * Strategy:
- * - Group by method + normalizedPath (same as clustering)
- * - Within each group, detect pagination patterns (same URL with different page/offset/cursor params)
- * - Remove retries: consecutive requests to the same URL within 5s with same method
- */
-export function deduplicateEntries(entries) {
-    const result = [];
-    const seenSignatures = new Map();
-    for (const entry of entries) {
-        const url = entry.entry.request.url;
-        const method = entry.entry.request.method;
-        const signature = `${method} ${stripPaginationParams(url)}`;
-        const timestamp = new Date(entry.entry.startedDateTime).getTime();
-        const seen = seenSignatures.get(signature);
-        if (seen) {
-            // Skip retries: same signature within 5 seconds
-            if (timestamp - seen.lastTime < 5000) {
-                seen.lastTime = timestamp;
-                seen.count++;
-                continue;
-            }
-            // Skip excessive pagination: keep at most 3 examples per endpoint
-            if (isPaginationVariant(url, entries, entry) && seen.count >= 3) {
-                seen.lastTime = timestamp;
-                seen.count++;
-                continue;
-            }
-        }
-        seenSignatures.set(signature, {
-            lastTime: timestamp,
-            count: (seen?.count ?? 0) + 1,
-        });
-        result.push(entry);
-    }
-    return result;
-}
-const PAGINATION_PARAMS = new Set([
-    'page',
-    'offset',
-    'limit',
-    'cursor',
-    'after',
-    'before',
-    'skip',
-    'take',
-    'per_page',
-    'page_size',
-    'pagesize',
-    'start',
-    'count',
-    'from',
-    'next_token',
-    'continuation',
-]);
-function stripPaginationParams(url) {
-    try {
-        const parsed = new URL(url);
-        for (const key of [...parsed.searchParams.keys()]) {
-            if (PAGINATION_PARAMS.has(key.toLowerCase())) {
-                parsed.searchParams.delete(key);
-            }
-        }
-        return `${parsed.origin}${parsed.pathname}${parsed.search}`;
-    }
-    catch {
-        return url;
-    }
-}
-function isPaginationVariant(url, allEntries, current) {
-    try {
-        const parsed = new URL(url);
-        const paramKeys = [...parsed.searchParams.keys()].map((k) => k.toLowerCase());
-        return paramKeys.some((k) => PAGINATION_PARAMS.has(k));
-    }
-    catch {
-        return false;
-    }
-}

package/dist/transformer/har-schema-inferrer.d.ts

@@ -1,15 +0,0 @@
-import type { JsonSchema } from '../types/index.js';
-/**
- * Infer a JSON Schema from a sample JSON value.
- * Handles objects, arrays, and primitives.
- */
-export declare function inferJsonSchema(value: unknown, depth?: number): JsonSchema;
-/**
- * Try to parse a response body as JSON and infer its schema.
- * Returns undefined if not JSON or parsing fails.
- */
-export declare function inferResponseSchema(body: string | undefined, mimeType: string): JsonSchema | undefined;
-/**
- * Try to parse a request body and infer its schema.
- */
-export declare function inferRequestBodySchema(text: string | undefined, mimeType: string): JsonSchema | undefined;

package/dist/transformer/har-schema-inferrer.js

@@ -1,90 +0,0 @@
-import { isDangerousKey } from '../utils/sanitize.js';
-const MAX_INFERENCE_DEPTH = 20;
-/**
- * Infer a JSON Schema from a sample JSON value.
- * Handles objects, arrays, and primitives.
- */
-export function inferJsonSchema(value, depth = 0) {
-    if (depth > MAX_INFERENCE_DEPTH) {
-        return { type: 'object' };
-    }
-    if (value === null || value === undefined) {
-        return { type: 'string' };
-    }
-    if (Array.isArray(value)) {
-        if (value.length === 0) {
-            return { type: 'array', items: {} };
-        }
-        return { type: 'array', items: inferJsonSchema(value[0], depth + 1) };
-    }
-    if (typeof value === 'object') {
-        const properties = {};
-        const required = [];
-        for (const [key, val] of Object.entries(value)) {
-            if (isDangerousKey(key))
-                continue;
-            properties[key] = inferJsonSchema(val, depth + 1);
-            if (val !== null && val !== undefined) {
-                required.push(key);
-            }
-        }
-        return {
-            type: 'object',
-            properties,
-            ...(required.length > 0 ? { required } : {}),
-        };
-    }
-    if (typeof value === 'number') {
-        return Number.isInteger(value) ? { type: 'integer' } : { type: 'number' };
-    }
-    if (typeof value === 'boolean') {
-        return { type: 'boolean' };
-    }
-    return { type: 'string' };
-}
-/**
- * Try to parse a response body as JSON and infer its schema.
- * Returns undefined if not JSON or parsing fails.
- */
-export function inferResponseSchema(body, mimeType) {
-    if (!body || !mimeType.includes('json'))
-        return undefined;
-    try {
-        const parsed = JSON.parse(body);
-        return inferJsonSchema(parsed);
-    }
-    catch {
-        return undefined;
-    }
-}
-/**
- * Try to parse a request body and infer its schema.
- */
-export function inferRequestBodySchema(text, mimeType) {
-    if (!text)
-        return undefined;
-    if (mimeType.includes('json')) {
-        try {
-            return inferJsonSchema(JSON.parse(text));
-        }
-        catch {
-            return undefined;
-        }
-    }
-    if (mimeType.includes('x-www-form-urlencoded')) {
-        const params = new URLSearchParams(text);
-        const properties = {};
-        const required = [];
-        for (const [key, value] of params) {
-            properties[key] = { type: 'string' };
-            required.push(key);
-            // Try to detect numbers/booleans
-            if (/^\d+$/.test(value))
-                properties[key] = { type: 'integer' };
-            else if (value === 'true' || value === 'false')
-                properties[key] = { type: 'boolean' };
-        }
-        return { type: 'object', properties, required };
-    }
-    return undefined;
-}

package/dist/transformer/har-to-operations.d.ts

@@ -1,13 +0,0 @@
-import type { OperationDescriptor } from '../types/index.js';
-import type { EntryCluster } from './har-clusterer.js';
-export interface HarConversionResult {
-    operations: OperationDescriptor[];
-    baseUrl: string;
-    detectedAuth: DetectedAuth[];
-}
-export interface DetectedAuth {
-    type: 'bearer' | 'basic' | 'apiKey';
-    headerName: string;
-    exampleValue?: string;
-}
-export declare function clustersToOperations(clusters: EntryCluster[]): HarConversionResult;

package/dist/transformer/har-to-operations.js

@@ -1,192 +0,0 @@
-import { mergeRequestBodySchemas } from './schema-merger.js';
-const AUTH_HEADER_PATTERNS = [
-    { pattern: /^Bearer\s+/i, schemeName: 'bearer' },
-    { pattern: /^Basic\s+/i, schemeName: 'basic' },
-    { pattern: /^Token\s+/i, schemeName: 'token' },
-];
-const CUSTOM_AUTH_HEADERS = [
-    'x-api-key',
-    'api-key',
-    'authorization-token',
-    'x-auth-token',
-    'x-access-token',
-    'x-csrf-token',
-    'x-session-token',
-];
-const SESSION_COOKIE_PATTERNS = [
-    /^sess/i,
-    /^sid$/i,
-    /^session/i,
-    /^token/i,
-    /^auth/i,
-    /^jwt/i,
-    /^connect\.sid$/i,
-];
-export function clustersToOperations(clusters) {
-    const operations = [];
-    const allAuth = new Map();
-    let baseUrl = '';
-    for (const cluster of clusters) {
-        if (!baseUrl)
-            baseUrl = cluster.baseUrl;
-        const canonical = pickCanonicalEntry(cluster.entries);
-        const entry = canonical.entry;
-        const auth = detectAuth(entry);
-        for (const a of auth) {
-            allAuth.set(a.headerName.toLowerCase(), a);
-        }
-        const operationId = generateOperationId(cluster.method, cluster.normalizedPath);
-        const parameters = [];
-        // Path params from normalization
-        for (const pp of canonical.pathParams) {
-            const schemaType = pp.inferredType === 'integer' ? 'integer' : 'string';
-            const schema = pp.inferredType === 'uuid' ? { type: 'string', format: 'uuid' } : { type: schemaType };
-            parameters.push({
-                name: pp.name,
-                in: 'path',
-                required: true,
-                description: pp.name,
-                schema,
-            });
-        }
-        // Query params merged across all entries in cluster
-        const queryMap = new Map();
-        for (const ne of cluster.entries) {
-            for (const qp of ne.queryParams) {
-                const existing = queryMap.get(qp.name);
-                if (existing) {
-                    existing.values.add(qp.exampleValue);
-                }
-                else {
-                    queryMap.set(qp.name, { values: new Set([qp.exampleValue]), type: qp.inferredType });
-                }
-            }
-        }
-        for (const [name, info] of queryMap) {
-            parameters.push({
-                name,
-                in: 'query',
-                required: false,
-                schema: { type: info.type },
-            });
-        }
-        // Request body — merge schemas across all entries in the cluster
-        let requestBody;
-        const bodyEntries = cluster.entries
-            .map((ne) => ne.entry.request.postData)
-            .filter((pd) => !!pd?.text)
-            .map((pd) => ({ text: pd.text, mimeType: pd.mimeType }));
-        if (bodyEntries.length > 0) {
-            const mergedSchema = mergeRequestBodySchemas(bodyEntries);
-            if (mergedSchema) {
-                requestBody = {
-                    required: true,
-                    contentType: bodyEntries[0].mimeType.split(';')[0].trim(),
-                    schema: mergedSchema,
-                };
-            }
-        }
-        // Security
-        const security = auth.map((a) => ({
-            schemeName: a.type,
-            scopes: [],
-        }));
-        operations.push({
-            operationId,
-            method: cluster.method,
-            path: cluster.normalizedPath,
-            summary: `${cluster.method.toUpperCase()} ${cluster.normalizedPath}`,
-            tags: [extractTag(cluster.normalizedPath)],
-            parameters,
-            requestBody,
-            responses: [],
-            security,
-            deprecated: false,
-        });
-    }
-    return {
-        operations,
-        baseUrl,
-        detectedAuth: [...allAuth.values()],
-    };
-}
-function pickCanonicalEntry(entries) {
-    // Prefer entries with 2xx responses
-    const successful = entries.filter((e) => e.entry.response.status >= 200 && e.entry.response.status < 300);
-    return successful[0] ?? entries[0];
-}
-function detectAuth(entry) {
-    const result = [];
-    for (const header of entry.request.headers) {
-        const name = header.name.toLowerCase();
-        if (name === 'authorization') {
-            for (const { pattern, schemeName } of AUTH_HEADER_PATTERNS) {
-                if (pattern.test(header.value)) {
-                    result.push({
-                        type: schemeName,
-                        headerName: 'Authorization',
-                        exampleValue: '[REDACTED]',
-                    });
-                    break;
-                }
-            }
-        }
-        if (CUSTOM_AUTH_HEADERS.includes(name)) {
-            result.push({
-                type: 'apiKey',
-                headerName: header.name,
-                exampleValue: '[REDACTED]',
-            });
-        }
-        // Detect cookie-based session auth
-        if (name === 'cookie') {
-            const cookies = header.value.split(';').map((c) => c.trim().split('=')[0]);
-            for (const cookieName of cookies) {
-                if (SESSION_COOKIE_PATTERNS.some((p) => p.test(cookieName))) {
-                    result.push({
-                        type: 'apiKey',
-                        headerName: 'Cookie',
-                        exampleValue: '[REDACTED]',
-                    });
-                    break;
-                }
-            }
-        }
-    }
-    return result;
-}
-function generateOperationId(method, path) {
-    const segments = path
-        .replace(/\{[^}]+\}/g, '')
-        .split('/')
-        .filter(Boolean);
-    const resource = segments[segments.length - 1] ?? 'resource';
-    switch (method.toLowerCase()) {
-        case 'get':
-            return path.includes('{') ? `get_${singularize(resource)}` : `list_${resource}`;
-        case 'post':
-            return `create_${singularize(resource)}`;
-        case 'put':
-        case 'patch':
-            return `update_${singularize(resource)}`;
-        case 'delete':
-            return `delete_${singularize(resource)}`;
-        default:
-            return `${method.toLowerCase()}_${resource}`;
-    }
-}
-function extractTag(path) {
-    const segments = path.split('/').filter((s) => s && !s.startsWith('{'));
-    // Skip api/v1/v2 prefixes
-    const meaningful = segments.filter((s) => !/^(api|v\d+)$/i.test(s));
-    return meaningful[0] ?? 'default';
-}
-function singularize(word) {
-    if (word.endsWith('ies'))
-        return word.slice(0, -3) + 'y';
-    if (word.endsWith('ses') || word.endsWith('xes') || word.endsWith('zes'))
-        return word.slice(0, -2);
-    if (word.endsWith('s') && !word.endsWith('ss'))
-        return word.slice(0, -1);
-    return word;
-}

package/dist/transformer/index.d.ts

@@ -1,8 +0,0 @@
-export { toToolName, toToolTitle, toFileName, toFunctionName } from './naming.js';
-export { detectAuthSchemes } from './auth-detector.js';
-export { buildToolDefinition, buildAllTools } from './tool-builder.js';
-export { clusterEntries } from './har-clusterer.js';
-export type { EntryCluster } from './har-clusterer.js';
-export { clustersToOperations } from './har-to-operations.js';
-export type { HarConversionResult, DetectedAuth } from './har-to-operations.js';
-export { inferJsonSchema, inferResponseSchema, inferRequestBodySchema, } from './har-schema-inferrer.js';

package/dist/transformer/index.js

@@ -1,6 +0,0 @@
-export { toToolName, toToolTitle, toFileName, toFunctionName } from './naming.js';
-export { detectAuthSchemes } from './auth-detector.js';
-export { buildToolDefinition, buildAllTools } from './tool-builder.js';
-export { clusterEntries } from './har-clusterer.js';
-export { clustersToOperations } from './har-to-operations.js';
-export { inferJsonSchema, inferResponseSchema, inferRequestBodySchema, } from './har-schema-inferrer.js';

package/dist/transformer/llm-namer.d.ts

@@ -1,6 +0,0 @@
-import type { OperationDescriptor } from '../types/index.js';
-/**
- * Use Claude to generate better tool names and descriptions
- * from HAR-captured request/response patterns.
- */
-export declare function improveToolNames(operations: OperationDescriptor[], model?: string): Promise<OperationDescriptor[]>;

package/dist/transformer/llm-namer.js

@@ -1,59 +0,0 @@
-import Anthropic from '@anthropic-ai/sdk';
-import { logger } from '../utils/logger.js';
-/**
- * Use Claude to generate better tool names and descriptions
- * from HAR-captured request/response patterns.
- */
-export async function improveToolNames(operations, model) {
-    const apiKey = process.env.ANTHROPIC_API_KEY;
-    if (!apiKey) {
-        logger.warn('ANTHROPIC_API_KEY not set — skipping LLM tool naming');
-        return operations;
-    }
-    const client = new Anthropic({ apiKey });
-    const operationSummaries = operations.map((op) => ({
-        method: op.method,
-        path: op.path,
-        currentId: op.operationId,
-        summary: op.summary,
-        paramNames: op.parameters.map((p) => p.name),
-        hasBody: !!op.requestBody,
-        tags: op.tags,
-    }));
-    const prompt = `Given these API operations captured from network traffic, suggest better operationId names and descriptions. Return a JSON array with one object per operation: { "index": number, "operationId": "camelCase name", "summary": "one-line description" }. Keep names concise (camelCase, under 40 chars). Only output JSON, no explanation.
-
-Operations:
-${JSON.stringify(operationSummaries, null, 2)}`;
-    try {
-        logger.info('Improving tool names with Claude...');
-        const message = await client.messages.create({
-            model: model ?? 'claude-sonnet-4-20250514',
-            max_tokens: 2048,
-            messages: [{ role: 'user', content: prompt }],
-        });
-        const content = message.content[0];
-        if (content.type !== 'text')
-            return operations;
-        let json = content.text.trim();
-        if (json.startsWith('```')) {
-            json = json.replace(/^```(?:json)?\n?/, '').replace(/\n?```$/, '');
-        }
-        const improvements = JSON.parse(json);
-        const result = operations.map((op, i) => {
-            const improvement = improvements.find((imp) => imp.index === i);
-            if (!improvement)
-                return op;
-            return {
-                ...op,
-                operationId: improvement.operationId || op.operationId,
-                summary: improvement.summary || op.summary,
-            };
-        });
-        logger.info(`Improved ${improvements.length} tool names`);
-        return result;
-    }
-    catch (err) {
-        logger.warn(`LLM naming failed, using defaults: ${err instanceof Error ? err.message : err}`);
-        return operations;
-    }
-}

package/dist/transformer/naming.d.ts

@@ -1,4 +0,0 @@
-export declare function toToolName(operationId: string): string;
-export declare function toToolTitle(operationId: string): string;
-export declare function toFileName(operationId: string): string;
-export declare function toFunctionName(operationId: string): string;

package/dist/transformer/naming.js

@@ -1,30 +0,0 @@
-export function toToolName(operationId) {
-    return toSnakeCase(operationId);
-}
-export function toToolTitle(operationId) {
-    const snake = toSnakeCase(operationId);
-    return snake
-        .split('_')
-        .map((w) => w.charAt(0).toUpperCase() + w.slice(1))
-        .join(' ');
-}
-export function toFileName(operationId) {
-    return toSnakeCase(operationId)
-        .replace(/_/g, '-')
-        .replace(/\.\./g, '')
-        .replace(/[/\\]/g, '')
-        .replace(/[^a-z0-9\-]/g, '');
-}
-export function toFunctionName(operationId) {
-    const snake = toSnakeCase(operationId);
-    return snake.replace(/_([a-z])/g, (_, c) => c.toUpperCase());
-}
-function toSnakeCase(str) {
-    return str
-        .replace(/([a-z0-9])([A-Z])/g, '$1_$2')
-        .replace(/([A-Z])([A-Z][a-z])/g, '$1_$2')
-        .replace(/[\s\-]+/g, '_')
-        .toLowerCase()
-        .replace(/^_+|_+$/g, '')
-        .replace(/_+/g, '_');
-}

package/dist/transformer/operation-filter.d.ts

@@ -1,13 +0,0 @@
-import type { OperationDescriptor } from '../types/index.js';
-export interface FilterOptions {
-    include?: string[];
-    exclude?: string[];
-}
-/**
- * Filter operations by tag or path pattern.
- * Patterns can be:
- *   - A tag name: "pets" matches operations tagged with "pets"
- *   - A path prefix: "/users*" matches /users, /users/{id}, etc.
- *   - A glob-like pattern: "*admin*" matches any operation with "admin" in path or tags
- */
-export declare function filterOperations(operations: OperationDescriptor[], options: FilterOptions): OperationDescriptor[];

package/dist/transformer/operation-filter.js

@@ -1,52 +0,0 @@
-/**
- * Filter operations by tag or path pattern.
- * Patterns can be:
- *   - A tag name: "pets" matches operations tagged with "pets"
- *   - A path prefix: "/users*" matches /users, /users/{id}, etc.
- *   - A glob-like pattern: "*admin*" matches any operation with "admin" in path or tags
- */
-export function filterOperations(operations, options) {
-    let result = operations;
-    if (options.include?.length) {
-        result = result.filter((op) => options.include.some((pattern) => matchesOperation(op, pattern)));
-    }
-    if (options.exclude?.length) {
-        result = result.filter((op) => !options.exclude.some((pattern) => matchesOperation(op, pattern)));
-    }
-    return result;
-}
-function matchesOperation(op, pattern) {
-    const lowerPattern = pattern.toLowerCase();
-    // Check tag match
-    if (op.tags.some((t) => t.toLowerCase() === lowerPattern))
-        return true;
-    // Check path match with simple glob support
-    if (matchGlob(op.path.toLowerCase(), lowerPattern))
-        return true;
-    // Check operationId match
-    if (op.operationId.toLowerCase().includes(lowerPattern))
-        return true;
-    return false;
-}
-function matchGlob(str, pattern) {
-    // Simple glob matching without regex to avoid ReDoS.
-    // Split pattern by '*' and check that all parts appear in order.
-    const parts = pattern.split('*');
-    let pos = 0;
-    for (let i = 0; i < parts.length; i++) {
-        const part = parts[i];
-        if (part === '')
-            continue;
-        const idx = str.indexOf(part, pos);
-        if (idx === -1)
-            return false;
-        // First segment must match at start, last at end
-        if (i === 0 && idx !== 0)
-            return false;
-        pos = idx + part.length;
-    }
-    // If pattern doesn't end with *, the string must end at pos
-    if (!pattern.endsWith('*') && pos !== str.length)
-        return false;
-    return true;
-}

package/dist/transformer/resource-builder.d.ts

@@ -1,12 +0,0 @@
-import type { OperationDescriptor } from '../types/index.js';
-import type { ResourceDefinition, PromptDefinition } from '../types/index.js';
-/**
- * Generate MCP resources from GET operations.
- * - List endpoints (no path params) → static resources
- * - Detail endpoints (with path params) → URI template resources
- */
-export declare function buildResources(operations: OperationDescriptor[]): ResourceDefinition[];
-/**
- * Generate MCP prompts — one per tag as a "workflow" prompt.
- */
-export declare function buildPrompts(operations: OperationDescriptor[]): PromptDefinition[];