#!/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
} from "./tools/fullstack.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 }],
["save_memory", { schema: saveMemorySchema, handler: saveMemoryHandler }],
["read_memory", { schema: readMemorySchema, handler: readMemoryHandler }],
["list_memories", { schema: listMemoriesSchema, handler: listMemoriesHandler }],
["clear_memory", { schema: clearMemorySchema, handler: clearMemoryHandler }],
["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 }],
// Linting tools
["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 }],
]);
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);
});