#!/usr/bin/env node
import { Server } from "@modelcontextprotocol/sdk/server/index.js";
import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
import {
CallToolRequestSchema,
ListResourcesRequestSchema,
ListToolsRequestSchema,
ReadResourceRequestSchema,
ListPromptsRequestSchema,
GetPromptRequestSchema,
} from "@modelcontextprotocol/sdk/types.js";
import { zodToJsonSchema } from "zod-to-json-schema";
// Import Types
import type { Language, Database, Framework, Resource, RegisteredTool } from "./types.js";
// Import Tools
import { sequentialThinkingSchema, sequentialThinkingHandler } from "./tools/thinking.js";
import { saveMemorySchema, readMemorySchema, listMemoriesSchema, clearMemorySchema, saveMemoryHandler, readMemoryHandler, listMemoriesHandler, clearMemoryHandler } from "./tools/memory.js";
import { validateCodeSchema, validateCodeHandler } from "./tools/validator.js";
import {
generateCursorRulesSchema, generateCursorRulesHandler,
generateGeminiConfigSchema, generateGeminiConfigHandler,
generateClaudeConfigSchema, generateClaudeConfigHandler,
generateWindsurfConfigSchema, generateWindsurfConfigHandler,
generateAiderConfigSchema, generateAiderConfigHandler,
generateClineConfigSchema, generateClineConfigHandler,
generateCopilotConfigSchema, generateCopilotConfigHandler
} from "./tools/aiconfigs.js";
import {
planTaskSchema, planTaskHandler,
reflectOnCodeSchema, reflectOnCodeHandler,
analyzeArchitectureSchema, analyzeArchitectureHandler,
debugProblemSchema, debugProblemHandler,
brainstormSolutionsSchema, brainstormSolutionsHandler,
compareApproachesSchema, compareApproachesHandler,
estimateComplexitySchema, estimateComplexityHandler,
generateTestsSchema, generateTestsHandler,
explainCodeSchema, explainCodeHandler
} from "./tools/cognitive.js";
import {
checkImportsSchema, checkImportsHandler,
lintCodeSchema, lintCodeHandler,
formatCodeSchema, formatCodeHandler
} from "./tools/linting.js";
import {
generateContinueConfigSchema, generateContinueConfigHandler,
generateTabnineConfigSchema, generateTabnineConfigHandler,
generateVSCodeTasksSchema, generateVSCodeTasksHandler,
generateVSCodeLaunchSchema, generateVSCodeLaunchHandler,
generateJetBrainsConfigSchema, generateJetBrainsConfigHandler
} from "./tools/ideconfigs.js";
import {
trackProjectSchema, trackProjectHandler,
checkDependenciesSchema, checkDependenciesHandler,
generateGitHubActionsSchema, generateGitHubActionsHandler,
fullStackScaffoldSchema, fullStackScaffoldHandler,
developerRulesSchema, developerRulesHandler,
enforceProjectStandardsSchema, enforceProjectStandardsHandler
} from "./tools/fullstack.js";
import {
analyzePythonAstSchema, analyzePythonAstHandler,
checkPythonDepsSchema, checkPythonDepsHandler
} from "./tools/python.js";
import {
analyzeGoModSchema, analyzeGoModHandler,
goStructHelperSchema, goStructHelperHandler
} from "./tools/go.js";
import {
generateTerraformResourceSchema, generateTerraformResourceHandler,
generateObservabilitySchema, generateObservabilityHandler,
generateK8sManifestSchema, generateK8sManifestHandler,
generateTerraformConfigSchema, generateTerraformConfigHandler,
generateNginxConfigSchema, generateNginxConfigHandler
} from "./tools/infrastructure.js";
import {
runTestsSafeSchema, runTestsSafeHandler,
analyzeCoverageSchema, analyzeCoverageHandler
} from "./tools/testing.js";
import {
generateSnippetSchema, generateSnippetHandler,
regexBuilderSchema, regexBuilderHandler
} from "./tools/generators.js";
import {
gitHelperSchema, gitHelperHandler,
packageJsonSchema, packageJsonHandler,
dockerfileSchema, dockerfileHandler,
envTemplateSchema, envTemplateHandler
} from "./tools/utilities.js";
import {
typescriptHelperSchema, typescriptHelperHandler,
apiClientSchema, apiClientHandler,
sqlHelperSchema, sqlHelperHandler,
readmeGeneratorSchema, readmeGeneratorHandler,
licenseGeneratorSchema, licenseGeneratorHandler
} from "./tools/advanced.js";
import {
decisionMatrixSchema, decisionMatrixHandler,
consequenceAnalysisSchema, consequenceAnalysisHandler,
conceptAssociationSchema, conceptAssociationHandler,
derivePatternsSchema, derivePatternsHandler,
researchSynthesisSchema, researchSynthesisHandler
} from "./tools/agentic.js";
import {
generateDiagramSchema, generateDiagramHandler,
visualizeSystemSchema, visualizeSystemHandler
} from "./tools/visualization.js";
import {
generateCommitMessageSchema, generateCommitMessageHandler,
generatePRDescriptionSchema, generatePRDescriptionHandler,
updateChangelogSchema, updateChangelogHandler
} from "./tools/communication.js";
import {
suggestToolChainSchema, suggestToolChainHandler,
projectProfilerSchema, projectProfilerHandler
} from "./tools/coordination.js";
import {
analyzeComplexitySchema, analyzeComplexityHandler,
securityScanSchema, securityScanHandler
} from "./tools/quality.js";
import {
convertFormatSchema, convertFormatHandler,
generateMockDataSchema, generateMockDataHandler
} from "./tools/data.js";
import {
listFilesSchema, listFilesHandler,
readFileSnippetSchema, readFileSnippetHandler,
searchFilesSchema, searchFilesHandler,
fileTreeSchema, fileTreeHandler
} from "./tools/filesystem.js";
import {
summarizeFilesSchema, summarizeFilesHandler,
aggregateContextSchema, aggregateContextHandler
} from "./tools/context.js";
import {
defineUserStoriesSchema, defineUserStoriesHandler,
createPersonasSchema, createPersonasHandler,
marketAnalysisSchema, marketAnalysisHandler
} from "./tools/product.js";
import {
getTemplateSchema, getTemplateHandler
} from "./tools/templates.js";
// Import Prompts
import { prompts, getPrompt } from "./prompts.js";
// Load Registries with proper typing
import languagesRegistry from "./data/languages.json" with { type: "json" };
import databasesRegistry from "./data/databases.json" with { type: "json" };
import frameworksRegistry from "./data/frameworks.json" with { type: "json" };
// --- Tool Registry Pattern (cleaner, extensible) ---
const toolRegistry: Map<string, RegisteredTool> = new Map([
["sequential_thinking", { schema: sequentialThinkingSchema, handler: sequentialThinkingHandler }],
["plan_task", { schema: planTaskSchema, handler: planTaskHandler }],
["reflect_on_code", { schema: reflectOnCodeSchema, handler: reflectOnCodeHandler }],
["analyze_architecture", { schema: analyzeArchitectureSchema, handler: analyzeArchitectureHandler }],
["debug_problem", { schema: debugProblemSchema, handler: debugProblemHandler }],
["brainstorm_solutions", { schema: brainstormSolutionsSchema, handler: brainstormSolutionsHandler }],
["compare_approaches", { schema: compareApproachesSchema, handler: compareApproachesHandler }],
["estimate_complexity", { schema: estimateComplexitySchema, handler: estimateComplexityHandler }],
["generate_tests", { schema: generateTestsSchema, handler: generateTestsHandler }],
["explain_code", { schema: explainCodeSchema, handler: explainCodeHandler }],
["check_imports", { schema: checkImportsSchema, handler: checkImportsHandler }],
["lint_code", { schema: lintCodeSchema, handler: lintCodeHandler }],
["format_code", { schema: formatCodeSchema, handler: formatCodeHandler }],
// IDE config tools
["generate_continue_config", { schema: generateContinueConfigSchema, handler: generateContinueConfigHandler }],
["generate_tabnine_config", { schema: generateTabnineConfigSchema, handler: generateTabnineConfigHandler }],
["generate_vscode_tasks", { schema: generateVSCodeTasksSchema, handler: generateVSCodeTasksHandler }],
["generate_vscode_launch", { schema: generateVSCodeLaunchSchema, handler: generateVSCodeLaunchHandler }],
["generate_jetbrains_config", { schema: generateJetBrainsConfigSchema, handler: generateJetBrainsConfigHandler }],
// Fullstack automation tools
["track_project", { schema: trackProjectSchema, handler: trackProjectHandler }],
["check_dependencies", { schema: checkDependenciesSchema, handler: checkDependenciesHandler }],
["generate_github_actions", { schema: generateGitHubActionsSchema, handler: generateGitHubActionsHandler }],
["full_stack_scaffold", { schema: fullStackScaffoldSchema, handler: fullStackScaffoldHandler }],
["developer_rules", { schema: developerRulesSchema, handler: developerRulesHandler }],
["enforce_project_standards", { schema: enforceProjectStandardsSchema, handler: enforceProjectStandardsHandler }],
// Code generator tools
["generate_snippet", { schema: generateSnippetSchema, handler: generateSnippetHandler }],
["regex_builder", { schema: regexBuilderSchema, handler: regexBuilderHandler }],
// Utility tools
["git_helper", { schema: gitHelperSchema, handler: gitHelperHandler }],
["generate_package_json", { schema: packageJsonSchema, handler: packageJsonHandler }],
["generate_dockerfile", { schema: dockerfileSchema, handler: dockerfileHandler }],
["generate_env_template", { schema: envTemplateSchema, handler: envTemplateHandler }],
// Advanced tools
["typescript_helper", { schema: typescriptHelperSchema, handler: typescriptHelperHandler }],
["generate_api_client", { schema: apiClientSchema, handler: apiClientHandler }],
["sql_helper", { schema: sqlHelperSchema, handler: sqlHelperHandler }],
["generate_readme", { schema: readmeGeneratorSchema, handler: readmeGeneratorHandler }],
["generate_license", { schema: licenseGeneratorSchema, handler: licenseGeneratorHandler }],
// Agentic tools
["decision_matrix", { schema: decisionMatrixSchema, handler: decisionMatrixHandler }],
["consequence_analysis", { schema: consequenceAnalysisSchema, handler: consequenceAnalysisHandler }],
["concept_association", { schema: conceptAssociationSchema, handler: conceptAssociationHandler }],
["derive_patterns", { schema: derivePatternsSchema, handler: derivePatternsHandler }],
["research_synthesis", { schema: researchSynthesisSchema, handler: researchSynthesisHandler }],
// Visualization tools
["generate_diagram", { schema: generateDiagramSchema, handler: generateDiagramHandler }],
["visualize_system", { schema: visualizeSystemSchema, handler: visualizeSystemHandler }],
// Communication tools
["generate_commit_message", { schema: generateCommitMessageSchema, handler: generateCommitMessageHandler }],
["generate_pr_description", { schema: generatePRDescriptionSchema, handler: generatePRDescriptionHandler }],
["update_changelog", { schema: updateChangelogSchema, handler: updateChangelogHandler }],
// Coordination tools
["suggest_tool_chain", { schema: suggestToolChainSchema, handler: suggestToolChainHandler }],
["project_profiler", { schema: projectProfilerSchema, handler: projectProfilerHandler }],
// Quality tools
["analyze_complexity", { schema: analyzeComplexitySchema, handler: analyzeComplexityHandler }],
["security_scan", { schema: securityScanSchema, handler: securityScanHandler }],
// Data tools
["convert_format", { schema: convertFormatSchema, handler: convertFormatHandler }],
["generate_mock_data", { schema: generateMockDataSchema, handler: generateMockDataHandler }],
// Filesystem tools
["list_files", { schema: listFilesSchema, handler: listFilesHandler }],
["read_file_snippet", { schema: readFileSnippetSchema, handler: readFileSnippetHandler }],
["validate_code", { schema: validateCodeSchema, handler: validateCodeHandler }],
["generate_cursor_rules", { schema: generateCursorRulesSchema, handler: generateCursorRulesHandler }],
["generate_gemini_config", { schema: generateGeminiConfigSchema, handler: generateGeminiConfigHandler }],
["generate_claude_config", { schema: generateClaudeConfigSchema, handler: generateClaudeConfigHandler }],
["generate_windsurf_config", { schema: generateWindsurfConfigSchema, handler: generateWindsurfConfigHandler }],
["generate_aider_config", { schema: generateAiderConfigSchema, handler: generateAiderConfigHandler }],
["generate_cline_config", { schema: generateClineConfigSchema, handler: generateClineConfigHandler }],
["generate_copilot_config", { schema: generateCopilotConfigSchema, handler: generateCopilotConfigHandler }],
// Product tools
["define_user_stories", { schema: defineUserStoriesSchema, handler: defineUserStoriesHandler }],
["create_personas", { schema: createPersonasSchema, handler: createPersonasHandler }],
["market_analysis", { schema: marketAnalysisSchema, handler: marketAnalysisHandler }],
// Context tools
["summarize_files", { schema: summarizeFilesSchema, handler: summarizeFilesHandler }],
["aggregate_context", { schema: aggregateContextSchema, handler: aggregateContextHandler }],
// Template tools
["get_template", { schema: getTemplateSchema, handler: getTemplateHandler }],
]);
const server = new Server(
{
name: "code-mcp",
version: "1.0.0",
},
{
capabilities: {
resources: {},
tools: {},
prompts: {},
},
}
);
// --- Resources ---
server.setRequestHandler(ListResourcesRequestSchema, async () => {
const langResources: Resource[] = (languagesRegistry.languages as Language[]).map((lang) => ({
uri: `code-rules://language/${lang.id}`,
name: `${lang.name} Coding Rules`,
mimeType: "text/markdown",
description: `Best practices for ${lang.name} (${lang.type})`
}));
const dbResources: Resource[] = (databasesRegistry.databases as Database[]).map((db) => ({
uri: `code-rules://database/${db.id}`,
name: `${db.name} Best Practices`,
mimeType: "text/markdown",
description: `${db.type} ${db.category} database patterns`
}));
const fwResources: Resource[] = (frameworksRegistry.frameworks as Framework[]).map((fw) => ({
uri: `code-rules://framework/${fw.id}`,
name: `${fw.name} Best Practices`,
mimeType: "text/markdown",
description: `${fw.type} framework for ${fw.language}`
}));
return {
resources: [...langResources, ...dbResources, ...fwResources],
};
});
server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
const uri = request.params.uri;
const parts = uri.replace("code-rules://", "").split("/");
const category = parts[0];
const id = parts[1];
if (category === "language") {
const lang = (languagesRegistry.languages as Language[]).find((l) => l.id === id);
if (!lang) throw new Error("Language not found");
return {
contents: [{
uri,
mimeType: "text/markdown",
text: `# ${lang.name} Coding Rules\n\n**Type**: ${lang.type}\n**Paradigms**: ${lang.paradigms.join(", ")}\n**Extensions**: ${lang.extensions.join(", ")}\n\n## Best Practices\n- Follow ${lang.name} official documentation and style guides\n- Use type hints/annotations where applicable\n- Write comprehensive tests for all critical code\n- Handle errors explicitly and gracefully\n\n## Common Pitfalls\n- Avoid global mutable state\n- Don't ignore error handling\n- Avoid premature optimization\n`
}],
};
}
if (category === "database") {
const db = (databasesRegistry.databases as Database[]).find((d) => d.id === id);
if (!db) throw new Error("Database not found");
return {
contents: [{
uri,
mimeType: "text/markdown",
text: `# ${db.name} Best Practices\n\n**Type**: ${db.type}\n**Category**: ${db.category}\n**Features**: ${db.features.join(", ")}\n\n## Connection Best Practices\n- Use connection pooling\n- Handle disconnections gracefully\n- Set appropriate timeouts\n\n## Query Optimization\n- Use indexes appropriately\n- Avoid N+1 queries\n- Use EXPLAIN to analyze queries\n`
}],
};
}
if (category === "framework") {
const fw = (frameworksRegistry.frameworks as Framework[]).find((f) => f.id === id);
if (!fw) throw new Error("Framework not found");
return {
contents: [{
uri,
mimeType: "text/markdown",
text: `# ${fw.name} Best Practices\n\n**Language**: ${fw.language}\n**Type**: ${fw.type}\n**Features**: ${fw.features.join(", ")}\n\n## Project Structure\n- Follow ${fw.name} conventions\n- Keep components small and focused\n- Separate concerns appropriately\n\n## Performance\n- Use lazy loading where possible\n- Optimize bundle size\n- Profile before optimizing\n`
}],
};
}
throw new Error("Unknown resource category");
});
// --- Tools (using registry pattern) ---
server.setRequestHandler(ListToolsRequestSchema, async () => {
return {
tools: Array.from(toolRegistry.values()).map(({ schema }) => ({
name: schema.name,
description: schema.description,
inputSchema: zodToJsonSchema(schema.inputSchema),
})),
};
});
server.setRequestHandler(CallToolRequestSchema, async (request) => {
try {
const { name, arguments: args } = request.params;
const tool = toolRegistry.get(name);
if (tool) {
return tool.handler(args);
}
throw new Error(`Tool not found: ${name}`);
} catch (error) {
const message = error instanceof Error ? error.message : "Unknown error";
return {
content: [{ type: "text", text: `Error: ${message}` }],
isError: true,
};
}
});
// --- Prompts ---
server.setRequestHandler(ListPromptsRequestSchema, async () => {
return {
prompts: Object.values(prompts).map(p => ({
name: p.name,
description: p.description,
arguments: p.arguments || []
}))
};
});
server.setRequestHandler(GetPromptRequestSchema, async (request) => {
const { name } = request.params;
const prompt = getPrompt(name);
if (!prompt) {
throw new Error(`Prompt not found: ${name}`);
}
return {
description: prompt.description,
messages: [
{
role: "user",
content: {
type: "text",
text: prompt.template
}
}
]
};
});
// --- Server Startup ---
async function run(): Promise<void> {
const transport = new StdioServerTransport();
await server.connect(transport);
console.error("Code-MCP Server running on stdio");
}
run().catch((error) => {
console.error("Fatal error running server:", error);
process.exit(1);
});