mcp-new 0.1.0

package/dist/cli.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/cli.js

@@ -0,0 +1,25 @@
+#!/usr/bin/env node
+import {
+  addToolCommand,
+  createCommand,
+  initCommand
+} from "./chunk-QRUHMGU5.js";
+
+// src/cli.ts
+import { Command } from "commander";
+import chalk from "chalk";
+var program = new Command();
+var logo = `
+  ${chalk.cyan("\u2554\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2557")}
+  ${chalk.cyan("\u2551")}   ${chalk.bold.white("mcp-new")}                            ${chalk.cyan("\u2551")}
+  ${chalk.cyan("\u2551")}   ${chalk.gray("Generate MCP servers in seconds")}    ${chalk.cyan("\u2551")}
+  ${chalk.cyan("\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u2550\u255D")}
+`;
+program.name("mcp-new").description("CLI tool for generating MCP (Model Context Protocol) servers").version("0.1.0").addHelpText("beforeAll", logo);
+program.argument("[project-name]", "Name of the project to create").option("-t, --typescript", "Use TypeScript template").option("-p, --python", "Use Python template").option("--skip-install", "Skip dependency installation").option("--from-openapi <path>", "Generate from OpenAPI/Swagger specification").option("--from-prompt", "Generate tools using AI from text description").option("-y, --yes", "Skip prompts and use defaults").action(createCommand);
+program.command("init").description("Initialize MCP server in the current directory").option("-t, --typescript", "Use TypeScript template").option("-p, --python", "Use Python template").option("--skip-install", "Skip dependency installation").option("-f, --force", "Initialize even if directory contains files").action(initCommand);
+program.command("add-tool").description("Add a new tool to an existing MCP server").option("-n, --name <name>", "Tool name (snake_case)").action(addToolCommand);
+program.parse();
+if (process.argv.length === 2) {
+  program.help();
+}

package/dist/index.d.ts

@@ -0,0 +1,516 @@
+import { z } from 'zod';
+
+declare const LanguageSchema: z.ZodEnum<["typescript", "python"]>;
+type Language = z.infer<typeof LanguageSchema>;
+declare const TransportSchema: z.ZodEnum<["stdio", "sse"]>;
+type Transport = z.infer<typeof TransportSchema>;
+declare const ToolParameterSchema: z.ZodObject<{
+    name: z.ZodString;
+    type: z.ZodEnum<["string", "number", "boolean", "object", "array"]>;
+    description: z.ZodString;
+    required: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    name: string;
+    description: string;
+    required: boolean;
+}, {
+    type: "string" | "number" | "boolean" | "object" | "array";
+    name: string;
+    description: string;
+    required?: boolean | undefined;
+}>;
+type ToolParameter = z.infer<typeof ToolParameterSchema>;
+declare const ToolConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodString;
+    parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        type: z.ZodEnum<["string", "number", "boolean", "object", "array"]>;
+        description: z.ZodString;
+        required: z.ZodDefault<z.ZodBoolean>;
+    }, "strip", z.ZodTypeAny, {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        name: string;
+        description: string;
+        required: boolean;
+    }, {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        name: string;
+        description: string;
+        required?: boolean | undefined;
+    }>, "many">>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    parameters: {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        name: string;
+        description: string;
+        required: boolean;
+    }[];
+}, {
+    name: string;
+    description: string;
+    parameters?: {
+        type: "string" | "number" | "boolean" | "object" | "array";
+        name: string;
+        description: string;
+        required?: boolean | undefined;
+    }[] | undefined;
+}>;
+type ToolConfig = z.infer<typeof ToolConfigSchema>;
+declare const ResourceConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    uri: z.ZodString;
+    description: z.ZodString;
+    mimeType: z.ZodOptional<z.ZodString>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    uri: string;
+    mimeType?: string | undefined;
+}, {
+    name: string;
+    description: string;
+    uri: string;
+    mimeType?: string | undefined;
+}>;
+type ResourceConfig = z.infer<typeof ResourceConfigSchema>;
+declare const ProjectConfigSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodDefault<z.ZodString>;
+    language: z.ZodEnum<["typescript", "python"]>;
+    transport: z.ZodEnum<["stdio", "sse"]>;
+    tools: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodString;
+        parameters: z.ZodDefault<z.ZodArray<z.ZodObject<{
+            name: z.ZodString;
+            type: z.ZodEnum<["string", "number", "boolean", "object", "array"]>;
+            description: z.ZodString;
+            required: z.ZodDefault<z.ZodBoolean>;
+        }, "strip", z.ZodTypeAny, {
+            type: "string" | "number" | "boolean" | "object" | "array";
+            name: string;
+            description: string;
+            required: boolean;
+        }, {
+            type: "string" | "number" | "boolean" | "object" | "array";
+            name: string;
+            description: string;
+            required?: boolean | undefined;
+        }>, "many">>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        parameters: {
+            type: "string" | "number" | "boolean" | "object" | "array";
+            name: string;
+            description: string;
+            required: boolean;
+        }[];
+    }, {
+        name: string;
+        description: string;
+        parameters?: {
+            type: "string" | "number" | "boolean" | "object" | "array";
+            name: string;
+            description: string;
+            required?: boolean | undefined;
+        }[] | undefined;
+    }>, "many">>;
+    resources: z.ZodDefault<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        uri: z.ZodString;
+        description: z.ZodString;
+        mimeType: z.ZodOptional<z.ZodString>;
+    }, "strip", z.ZodTypeAny, {
+        name: string;
+        description: string;
+        uri: string;
+        mimeType?: string | undefined;
+    }, {
+        name: string;
+        description: string;
+        uri: string;
+        mimeType?: string | undefined;
+    }>, "many">>;
+    includeExampleTool: z.ZodDefault<z.ZodBoolean>;
+    skipInstall: z.ZodDefault<z.ZodBoolean>;
+    initGit: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    name: string;
+    description: string;
+    language: "typescript" | "python";
+    transport: "stdio" | "sse";
+    tools: {
+        name: string;
+        description: string;
+        parameters: {
+            type: "string" | "number" | "boolean" | "object" | "array";
+            name: string;
+            description: string;
+            required: boolean;
+        }[];
+    }[];
+    resources: {
+        name: string;
+        description: string;
+        uri: string;
+        mimeType?: string | undefined;
+    }[];
+    includeExampleTool: boolean;
+    skipInstall: boolean;
+    initGit: boolean;
+}, {
+    name: string;
+    language: "typescript" | "python";
+    transport: "stdio" | "sse";
+    description?: string | undefined;
+    tools?: {
+        name: string;
+        description: string;
+        parameters?: {
+            type: "string" | "number" | "boolean" | "object" | "array";
+            name: string;
+            description: string;
+            required?: boolean | undefined;
+        }[] | undefined;
+    }[] | undefined;
+    resources?: {
+        name: string;
+        description: string;
+        uri: string;
+        mimeType?: string | undefined;
+    }[] | undefined;
+    includeExampleTool?: boolean | undefined;
+    skipInstall?: boolean | undefined;
+    initGit?: boolean | undefined;
+}>;
+type ProjectConfig = z.infer<typeof ProjectConfigSchema>;
+interface GeneratorContext {
+    config: ProjectConfig;
+    outputDir: string;
+    templateDir: string;
+}
+interface CLIOptions {
+    typescript?: boolean;
+    python?: boolean;
+    skipInstall?: boolean;
+    fromOpenapi?: string;
+    fromPrompt?: boolean;
+    yes?: boolean;
+}
+
+interface MCPToolInputSchema {
+    type: 'object';
+    properties: Record<string, MCPPropertySchema>;
+    required?: string[];
+}
+interface MCPPropertySchema {
+    type: 'string' | 'number' | 'boolean' | 'object' | 'array';
+    description?: string;
+    items?: MCPPropertySchema;
+    properties?: Record<string, MCPPropertySchema>;
+    enum?: string[];
+}
+interface MCPTool {
+    name: string;
+    description: string;
+    inputSchema: MCPToolInputSchema;
+}
+interface MCPResource {
+    uri: string;
+    name: string;
+    description?: string;
+    mimeType?: string;
+}
+interface MCPPrompt {
+    name: string;
+    description?: string;
+    arguments?: MCPPromptArgument[];
+}
+interface MCPPromptArgument {
+    name: string;
+    description?: string;
+    required?: boolean;
+}
+interface MCPServerCapabilities {
+    tools?: Record<string, never>;
+    resources?: Record<string, never>;
+    prompts?: Record<string, never>;
+}
+interface MCPServerInfo {
+    name: string;
+    version: string;
+    capabilities: MCPServerCapabilities;
+}
+
+interface OpenAPISpec {
+    openapi: string;
+    info: OpenAPIInfo;
+    servers?: OpenAPIServer[];
+    paths: Record<string, OpenAPIPathItem>;
+    components?: OpenAPIComponents;
+}
+interface OpenAPIInfo {
+    title: string;
+    description?: string;
+    version: string;
+}
+interface OpenAPIServer {
+    url: string;
+    description?: string;
+}
+interface OpenAPIPathItem {
+    get?: OpenAPIOperation;
+    post?: OpenAPIOperation;
+    put?: OpenAPIOperation;
+    delete?: OpenAPIOperation;
+    patch?: OpenAPIOperation;
+    options?: OpenAPIOperation;
+    head?: OpenAPIOperation;
+}
+interface OpenAPIOperation {
+    operationId?: string;
+    summary?: string;
+    description?: string;
+    tags?: string[];
+    parameters?: OpenAPIParameter[];
+    requestBody?: OpenAPIRequestBody;
+    responses: Record<string, OpenAPIResponse>;
+    deprecated?: boolean;
+}
+interface OpenAPIParameter {
+    name: string;
+    in: 'query' | 'header' | 'path' | 'cookie';
+    description?: string;
+    required?: boolean;
+    schema: OpenAPISchema;
+}
+interface OpenAPIRequestBody {
+    description?: string;
+    required?: boolean;
+    content: Record<string, OpenAPIMediaType>;
+}
+interface OpenAPIMediaType {
+    schema: OpenAPISchema;
+}
+interface OpenAPIResponse {
+    description: string;
+    content?: Record<string, OpenAPIMediaType>;
+}
+interface OpenAPISchema {
+    type?: string;
+    format?: string;
+    description?: string;
+    properties?: Record<string, OpenAPISchema>;
+    items?: OpenAPISchema;
+    required?: string[];
+    enum?: string[];
+    $ref?: string;
+    allOf?: OpenAPISchema[];
+    oneOf?: OpenAPISchema[];
+    anyOf?: OpenAPISchema[];
+}
+interface OpenAPIComponents {
+    schemas?: Record<string, OpenAPISchema>;
+    responses?: Record<string, OpenAPIResponse>;
+    parameters?: Record<string, OpenAPIParameter>;
+    requestBodies?: Record<string, OpenAPIRequestBody>;
+}
+interface ParsedEndpoint {
+    path: string;
+    method: string;
+    operationId: string;
+    summary: string;
+    description: string;
+    parameters: ParsedParameter[];
+    requestBody?: ParsedRequestBody;
+    tags: string[];
+}
+interface ParsedParameter {
+    name: string;
+    in: string;
+    type: string;
+    description: string;
+    required: boolean;
+}
+interface ParsedRequestBody {
+    required: boolean;
+    schema: OpenAPISchema;
+}
+
+declare abstract class BaseGenerator {
+    protected config: ProjectConfig;
+    protected outputDir: string;
+    protected templateDir: string;
+    constructor(context: GeneratorContext);
+    abstract generate(): Promise<void>;
+    protected createProjectStructure(): Promise<void>;
+    protected renderTemplates(): Promise<void>;
+    protected getTemplateData(): Record<string, unknown>;
+    protected installDependencies(): Promise<void>;
+    private installNodeDependencies;
+    private installPythonDependencies;
+    private checkCommand;
+    protected initializeGit(): Promise<void>;
+    protected checkOutputDir(): Promise<boolean>;
+}
+declare function createGeneratorContext(config: ProjectConfig, outputPath?: string): GeneratorContext;
+
+declare class WizardGenerator extends BaseGenerator {
+    constructor(context: GeneratorContext);
+    generate(): Promise<void>;
+}
+declare function generateFromWizard(config: ProjectConfig, outputPath?: string): Promise<void>;
+
+declare class OpenAPIGenerator extends BaseGenerator {
+    private _endpoints;
+    constructor(context: GeneratorContext);
+    get endpoints(): ParsedEndpoint[];
+    generate(): Promise<void>;
+    setEndpoints(endpoints: ParsedEndpoint[]): void;
+}
+declare function generateFromOpenAPI(specPath: string, baseConfig: Partial<ProjectConfig>): Promise<void>;
+
+declare class PromptGenerator extends BaseGenerator {
+    constructor(context: GeneratorContext);
+    generate(): Promise<void>;
+}
+declare function generateFromPrompt(baseConfig: Partial<ProjectConfig>): Promise<void>;
+
+declare function parseOpenAPISpec(content: string): Promise<ParsedEndpoint[]>;
+declare function selectEndpoints(endpoints: ParsedEndpoint[]): Promise<ParsedEndpoint[]>;
+declare function endpointToMCPTool(endpoint: ParsedEndpoint): {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: string;
+        properties: Record<string, unknown>;
+        required: string[] | undefined;
+    };
+};
+
+declare function parseSwaggerSpec(content: string): Promise<ParsedEndpoint[]>;
+
+declare function parsePostmanCollection(content: string): Promise<ParsedEndpoint[]>;
+
+declare const logger: {
+    info: (message: string) => void;
+    success: (message: string) => void;
+    warning: (message: string) => void;
+    error: (message: string) => void;
+    step: (step: number, total: number, message: string) => void;
+    title: (message: string) => void;
+    blank: () => void;
+    list: (items: string[]) => void;
+    code: (code: string) => void;
+    box: (title: string, content: string[]) => void;
+    nextSteps: (projectName: string, language: string) => void;
+};
+
+interface SpinnerInstance {
+    start: (text?: string) => SpinnerInstance;
+    stop: () => SpinnerInstance;
+    succeed: (text?: string) => SpinnerInstance;
+    fail: (text?: string) => SpinnerInstance;
+    warn: (text?: string) => SpinnerInstance;
+    info: (text?: string) => SpinnerInstance;
+    text: string;
+}
+declare function createSpinner(text?: string): SpinnerInstance;
+declare function withSpinner<T>(text: string, fn: () => Promise<T>, successText?: string, failText?: string): Promise<T>;
+
+declare const projectNameRegex: RegExp;
+declare function validateProjectName(name: string): {
+    valid: boolean;
+    error?: string;
+};
+declare function validateToolName(name: string): {
+    valid: boolean;
+    error?: string;
+};
+declare function validateUrl(url: string): {
+    valid: boolean;
+    error?: string;
+};
+declare function validateFilePath(path: string): {
+    valid: boolean;
+    error?: string;
+};
+declare function parseAndValidate<T>(schema: z.ZodSchema<T>, data: unknown): T;
+declare function safeParseAndValidate<T>(schema: z.ZodSchema<T>, data: unknown): {
+    success: true;
+    data: T;
+} | {
+    success: false;
+    error: z.ZodError;
+};
+
+declare function ensureDir(dirPath: string): Promise<void>;
+declare function writeFile(filePath: string, content: string): Promise<void>;
+declare function readFile(filePath: string): Promise<string>;
+declare function copyFile(src: string, dest: string): Promise<void>;
+declare function copyDir(src: string, dest: string): Promise<void>;
+declare function exists(filePath: string): Promise<boolean>;
+declare function remove(filePath: string): Promise<void>;
+declare function readDir(dirPath: string): Promise<string[]>;
+declare function isDirectory(filePath: string): Promise<boolean>;
+declare function renderTemplate(templatePath: string, data: Record<string, unknown>): Promise<string>;
+declare function renderTemplateToFile(templatePath: string, outputPath: string, data: Record<string, unknown>): Promise<void>;
+declare function walkDir(dirPath: string, callback: (filePath: string, isDir: boolean) => Promise<void>): Promise<void>;
+declare function getTemplateDir(): string;
+declare function resolveOutputPath(basePath: string, ...segments: string[]): string;
+
+declare function isGitInstalled(): Promise<boolean>;
+declare function initGitRepository(projectPath: string): Promise<void>;
+declare function createInitialCommit(projectPath: string): Promise<void>;
+declare function getGitUser(): Promise<{
+    name?: string;
+    email?: string;
+}>;
+declare function isInsideGitRepository(dirPath: string): Promise<boolean>;
+
+declare function promptProjectName(defaultName?: string): Promise<string>;
+declare function promptProjectDescription(): Promise<string>;
+
+declare function promptLanguage(): Promise<Language>;
+
+declare function promptTransport(): Promise<Transport>;
+
+declare function promptIncludeExampleTool(): Promise<boolean>;
+declare function promptAddTools(): Promise<boolean>;
+declare function promptToolConfig(): Promise<ToolConfig>;
+declare function promptMultipleTools(): Promise<ToolConfig[]>;
+
+declare function promptAddResources(): Promise<boolean>;
+declare function promptResourceConfig(): Promise<ResourceConfig>;
+declare function promptMultipleResources(): Promise<ResourceConfig[]>;
+
+interface WizardOptions {
+    defaultName?: string;
+    skipDescription?: boolean;
+    skipAdvanced?: boolean;
+    presetLanguage?: 'typescript' | 'python';
+}
+declare function runWizard(options?: WizardOptions): Promise<ProjectConfig>;
+declare function runQuickWizard(defaultName?: string, presetLanguage?: 'typescript' | 'python'): Promise<ProjectConfig>;
+
+declare function createCommand(projectName: string | undefined, options: CLIOptions): Promise<void>;
+
+interface InitOptions {
+    typescript?: boolean;
+    python?: boolean;
+    skipInstall?: boolean;
+    force?: boolean;
+}
+declare function initCommand(options: InitOptions): Promise<void>;
+
+interface AddToolOptions {
+    name?: string;
+}
+declare function addToolCommand(options: AddToolOptions): Promise<void>;
+
+export { BaseGenerator, type CLIOptions, type GeneratorContext, type Language, LanguageSchema, type MCPPrompt, type MCPPromptArgument, type MCPPropertySchema, type MCPResource, type MCPServerCapabilities, type MCPServerInfo, type MCPTool, type MCPToolInputSchema, type OpenAPIComponents, OpenAPIGenerator, type OpenAPIInfo, type OpenAPIMediaType, type OpenAPIOperation, type OpenAPIParameter, type OpenAPIPathItem, type OpenAPIRequestBody, type OpenAPIResponse, type OpenAPISchema, type OpenAPIServer, type OpenAPISpec, type ParsedEndpoint, type ParsedParameter, type ParsedRequestBody, type ProjectConfig, ProjectConfigSchema, PromptGenerator, type ResourceConfig, ResourceConfigSchema, type SpinnerInstance, type ToolConfig, ToolConfigSchema, type ToolParameter, ToolParameterSchema, type Transport, TransportSchema, WizardGenerator, type WizardOptions, addToolCommand, copyDir, copyFile, createCommand, createGeneratorContext, createInitialCommit, createSpinner, endpointToMCPTool, ensureDir, exists, generateFromOpenAPI, generateFromPrompt, generateFromWizard, getGitUser, getTemplateDir, initCommand, initGitRepository, isDirectory, isGitInstalled, isInsideGitRepository, logger, parseAndValidate, parseOpenAPISpec, parsePostmanCollection, parseSwaggerSpec, projectNameRegex, promptAddResources, promptAddTools, promptIncludeExampleTool, promptLanguage, promptMultipleResources, promptMultipleTools, promptProjectDescription, promptProjectName, promptResourceConfig, promptToolConfig, promptTransport, readDir, readFile, remove, renderTemplate, renderTemplateToFile, resolveOutputPath, runQuickWizard, runWizard, safeParseAndValidate, selectEndpoints, validateFilePath, validateProjectName, validateToolName, validateUrl, walkDir, withSpinner, writeFile };