midnight-mcp 0.1.41 → 0.2.2

package/dist/server.js

@@ -1,696 +0,0 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
-import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourceTemplatesRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, SetLevelRequestSchema, CompleteRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
-import { logger, formatErrorResponse, setMCPLogCallback, trackToolCall, } from "./utils/index.js";
-import { vectorStore } from "./db/index.js";
-import { allTools } from "./tools/index.js";
-import { allResources, getDocumentation, getCode, getSchema, } from "./resources/index.js";
-import { promptDefinitions, generatePrompt } from "./prompts/index.js";
-import { registerSamplingCallback } from "./services/index.js";
-import { createRequire } from "module";
-// Read version from package.json (single source of truth)
-const require = createRequire(import.meta.url);
-const packageJson = require("../package.json");
-const CURRENT_VERSION = packageJson.version;
-const SERVER_INFO = {
-    name: "midnight-mcp",
-    version: CURRENT_VERSION,
-    description: "MCP Server for Midnight Blockchain Development",
-};
-// Version check state
-let versionCheckResult = {
-    isOutdated: false,
-    latestVersion: CURRENT_VERSION,
-    updateMessage: null,
-};
-/**
- * Check for updates against npm registry (runs at startup)
- */
-async function checkForUpdates() {
-    try {
-        const controller = new AbortController();
-        const timeoutId = setTimeout(() => controller.abort(), 5000); // 5s timeout
-        const response = await fetch("https://registry.npmjs.org/midnight-mcp/latest", { signal: controller.signal });
-        clearTimeout(timeoutId);
-        if (!response.ok)
-            return;
-        const data = (await response.json());
-        const latestVersion = data.version;
-        if (latestVersion !== CURRENT_VERSION) {
-            versionCheckResult = {
-                isOutdated: true,
-                latestVersion,
-                updateMessage: `⚠️ UPDATE AVAILABLE: v${latestVersion} (you have v${CURRENT_VERSION}). ` +
-                    `Run: rm -rf ~/.npm/_npx && restart Claude Desktop. ` +
-                    `Or update config to use: "midnight-mcp@latest"`,
-            };
-            logger.warn(`Outdated version detected: v${CURRENT_VERSION} -> v${latestVersion}`);
-        }
-    }
-    catch {
-        // Silently ignore version check failures (offline, timeout, etc.)
-    }
-}
-/**
- * Get update warning if outdated (to include in responses)
- */
-export function getUpdateWarning() {
-    return versionCheckResult.updateMessage;
-}
-// Resource subscriptions tracking
-const resourceSubscriptions = new Set();
-/**
- * Clear all subscriptions (useful for server restart/testing)
- */
-export function clearSubscriptions() {
-    resourceSubscriptions.clear();
-    logger.debug("Subscriptions cleared");
-}
-// Resource templates for parameterized resources (RFC 6570 URI Templates)
-const resourceTemplates = [
-    {
-        uriTemplate: "midnight://code/{owner}/{repo}/{path}",
-        name: "Repository Code",
-        title: "📄 Repository Code Files",
-        description: "Access code files from any Midnight repository by specifying owner, repo, and file path",
-        mimeType: "text/plain",
-    },
-    {
-        uriTemplate: "midnight://docs/{section}/{topic}",
-        name: "Documentation",
-        title: "📚 Documentation Sections",
-        description: "Access documentation by section (guides, api, concepts) and topic",
-        mimeType: "text/markdown",
-    },
-    {
-        uriTemplate: "midnight://examples/{category}/{name}",
-        name: "Example Contracts",
-        title: "📝 Example Contracts",
-        description: "Access example contracts by category (counter, bboard, token, voting) and name",
-        mimeType: "text/x-compact",
-    },
-    {
-        uriTemplate: "midnight://schema/{type}",
-        name: "Schema Definitions",
-        title: "🔧 Schema Definitions",
-        description: "Access JSON schemas for contract AST, transactions, and proofs",
-        mimeType: "application/json",
-    },
-];
-/**
- * Create and configure the MCP server
- */
-// Current MCP logging level (controlled by client)
-let mcpLogLevel = "info";
-// Server instance for sending notifications
-let serverInstance = null;
-// Track if server is connected (can send notifications)
-let isConnected = false;
-/**
- * Mark server as connected (safe to send notifications)
- */
-export function setServerConnected(connected) {
-    isConnected = connected;
-}
-/**
- * Send a log message to the MCP client
- * This allows clients to see server logs for debugging
- */
-export function sendLogToClient(level, loggerName, data) {
-    // Only send if server exists AND is connected
-    if (!serverInstance || !isConnected)
-        return;
-    // Map levels to numeric values for comparison
-    const levelValues = {
-        debug: 0,
-        info: 1,
-        notice: 2,
-        warning: 3,
-        error: 4,
-        critical: 5,
-        alert: 6,
-        emergency: 7,
-    };
-    // Only send if level meets threshold
-    if (levelValues[level] < levelValues[mcpLogLevel])
-        return;
-    try {
-        serverInstance.notification({
-            method: "notifications/message",
-            params: {
-                level,
-                logger: loggerName,
-                data,
-            },
-        });
-    }
-    catch {
-        // Ignore notification errors
-    }
-}
-/**
- * Send a progress notification to the MCP client
- * Used for long-running operations like compound tools
- */
-export function sendProgressNotification(progressToken, progress, total, message) {
-    if (!serverInstance)
-        return;
-    try {
-        serverInstance.notification({
-            method: "notifications/progress",
-            params: {
-                progressToken,
-                progress,
-                ...(total !== undefined && { total }),
-                ...(message && { message }),
-            },
-        });
-    }
-    catch {
-        // Ignore notification errors
-    }
-}
-export function createServer() {
-    const server = new Server(SERVER_INFO, {
-        capabilities: {
-            tools: {
-                listChanged: true,
-            },
-            resources: {
-                subscribe: true,
-                listChanged: true,
-            },
-            prompts: {
-                listChanged: true,
-            },
-            logging: {},
-            completions: {},
-        },
-    });
-    // Store server instance for logging notifications
-    serverInstance = server;
-    // Wire up MCP logging - send logger output to client
-    setMCPLogCallback((level, loggerName, data) => {
-        sendLogToClient(level, loggerName, data);
-    });
-    // Register tool handlers
-    registerToolHandlers(server);
-    // Register resource handlers
-    registerResourceHandlers(server);
-    // Register prompt handlers
-    registerPromptHandlers(server);
-    // Register subscription handlers
-    registerSubscriptionHandlers(server);
-    // Register logging handler
-    registerLoggingHandler(server);
-    // Register completions handler
-    registerCompletionsHandler(server);
-    // Setup sampling callback if available
-    setupSampling(server);
-    return server;
-}
-/**
- * Register logging handler for MCP logging capability
- */
-function registerLoggingHandler(server) {
-    server.setRequestHandler(SetLevelRequestSchema, async (request) => {
-        const { level } = request.params;
-        mcpLogLevel = level;
-        logger.info(`MCP log level set to: ${level}`);
-        sendLogToClient("info", "midnight-mcp", {
-            message: `Log level changed to ${level}`,
-        });
-        return {};
-    });
-}
-// Completion suggestions for prompt arguments
-const COMPLETION_VALUES = {
-    "midnight:create-contract": {
-        contractType: [
-            "token",
-            "voting",
-            "credential",
-            "auction",
-            "escrow",
-            "custom",
-        ],
-        privacyLevel: ["full", "partial", "public"],
-        complexity: ["beginner", "intermediate", "advanced"],
-    },
-    "midnight:review-contract": {
-        focusAreas: [
-            "security",
-            "performance",
-            "privacy",
-            "readability",
-            "gas-optimization",
-        ],
-    },
-    "midnight:explain-concept": {
-        concept: [
-            "zk-proofs",
-            "circuits",
-            "witnesses",
-            "ledger",
-            "state-management",
-            "privacy-model",
-            "token-transfers",
-            "merkle-trees",
-        ],
-        level: ["beginner", "intermediate", "advanced"],
-    },
-    "midnight:compare-approaches": {
-        approaches: [
-            "token-standards",
-            "state-management",
-            "privacy-patterns",
-            "circuit-design",
-        ],
-    },
-    "midnight:debug-contract": {
-        errorType: [
-            "compilation",
-            "runtime",
-            "logic",
-            "privacy-leak",
-            "state-corruption",
-        ],
-    },
-};
-/**
- * Register completions handler for argument autocompletion
- */
-function registerCompletionsHandler(server) {
-    server.setRequestHandler(CompleteRequestSchema, async (request) => {
-        const { ref, argument } = request.params;
-        if (ref.type !== "ref/prompt") {
-            return { completion: { values: [], hasMore: false } };
-        }
-        const promptName = ref.name;
-        const argName = argument.name;
-        const currentValue = argument.value?.toLowerCase() || "";
-        // Get completion values for this prompt/argument
-        const promptCompletions = COMPLETION_VALUES[promptName];
-        if (!promptCompletions) {
-            return { completion: { values: [], hasMore: false } };
-        }
-        const argValues = promptCompletions[argName];
-        if (!argValues) {
-            return { completion: { values: [], hasMore: false } };
-        }
-        // Filter by current input
-        const filtered = argValues.filter((v) => v.toLowerCase().includes(currentValue));
-        return {
-            completion: {
-                values: filtered.slice(0, 20),
-                total: filtered.length,
-                hasMore: filtered.length > 20,
-            },
-        };
-    });
-}
-/**
- * Register tool handlers
- */
-function registerToolHandlers(server) {
-    // List available tools with annotations and output schemas
-    server.setRequestHandler(ListToolsRequestSchema, async () => {
-        logger.debug("Listing tools");
-        return {
-            tools: allTools.map((tool) => ({
-                name: tool.name,
-                description: tool.description,
-                inputSchema: tool.inputSchema,
-                // Include output schema if defined
-                ...(tool.outputSchema && { outputSchema: tool.outputSchema }),
-                // Include annotations if defined
-                ...(tool.annotations && { annotations: tool.annotations }),
-            })),
-        };
-    });
-    // Handle tool calls
-    server.setRequestHandler(CallToolRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        logger.info(`Tool called: ${name}`, { args });
-        const startTime = Date.now();
-        const tool = allTools.find((t) => t.name === name);
-        if (!tool) {
-            const availableTools = allTools
-                .map((t) => t.name)
-                .slice(0, 5)
-                .join(", ");
-            // Track failed tool call (unknown tool)
-            trackToolCall(name, false, Date.now() - startTime, CURRENT_VERSION);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify({
-                            error: `Unknown tool: ${name}`,
-                            suggestion: `Available tools include: ${availableTools}...`,
-                            hint: "Use ListTools to see all available tools",
-                        }, null, 2),
-                    },
-                ],
-                isError: true,
-            };
-        }
-        try {
-            const result = await tool.handler(args);
-            const durationMs = Date.now() - startTime;
-            // Track successful tool call (fire-and-forget, won't block response)
-            trackToolCall(name, true, durationMs, CURRENT_VERSION);
-            // Include prominent update prompt in ALL responses when outdated
-            const updateWarning = getUpdateWarning();
-            if (updateWarning && versionCheckResult.isOutdated) {
-                // Prepend update notice with MANUAL instructions (auto-update not possible in sandbox)
-                const updatePrompt = {
-                    "🚨 UPDATE AVAILABLE": {
-                        message: `You are using v${CURRENT_VERSION} but v${versionCheckResult.latestVersion} is available.`,
-                        userAction: {
-                            instruction: "Tell the user to update manually. Auto-update is NOT possible because you run in a sandboxed environment without access to local files.",
-                            steps: [
-                                "1. Edit config file to use 'midnight-mcp@latest' instead of 'midnight-mcp'",
-                                "2. Run: rm -rf ~/.npm/_npx (to clear npm cache)",
-                                "3. Restart the editor completely (Cmd+Q on Mac, then reopen)",
-                            ],
-                            configLocations: {
-                                claudeDesktop: "~/Library/Application Support/Claude/claude_desktop_config.json",
-                                cursor: ".cursor/mcp.json",
-                                vscode: ".vscode/mcp.json",
-                                windsurf: "~/.codeium/windsurf/mcp_config.json",
-                            },
-                        },
-                        note: "If user already has @latest in config, they just need to clear cache (rm -rf ~/.npm/_npx) and restart.",
-                    },
-                    result,
-                };
-                return {
-                    content: [
-                        {
-                            type: "text",
-                            text: JSON.stringify(updatePrompt, null, 2),
-                        },
-                    ],
-                };
-            }
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(result, null, 2),
-                    },
-                ],
-                // Include structured content for machine-readable responses
-                // This allows clients to parse results without JSON.parse()
-                structuredContent: result,
-            };
-        }
-        catch (error) {
-            const durationMs = Date.now() - startTime;
-            logger.error(`Tool error: ${name}`, { error: String(error) });
-            // Track failed tool call
-            trackToolCall(name, false, durationMs, CURRENT_VERSION);
-            const errorResponse = formatErrorResponse(error, `tool:${name}`);
-            return {
-                content: [
-                    {
-                        type: "text",
-                        text: JSON.stringify(errorResponse, null, 2),
-                    },
-                ],
-                isError: true,
-            };
-        }
-    });
-}
-/**
- * Register resource handlers
- */
-function registerResourceHandlers(server) {
-    // List available resources
-    server.setRequestHandler(ListResourcesRequestSchema, async () => {
-        logger.debug("Listing resources");
-        return {
-            resources: allResources.map((resource) => ({
-                uri: resource.uri,
-                name: resource.name,
-                description: resource.description,
-                mimeType: resource.mimeType,
-            })),
-        };
-    });
-    // List resource templates (RFC 6570 URI Templates)
-    server.setRequestHandler(ListResourceTemplatesRequestSchema, async () => {
-        logger.debug("Listing resource templates");
-        return {
-            resourceTemplates: resourceTemplates.map((template) => ({
-                uriTemplate: template.uriTemplate,
-                name: template.name,
-                title: template.title,
-                description: template.description,
-                mimeType: template.mimeType,
-            })),
-        };
-    });
-    // Read resource content
-    server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
-        const { uri } = request.params;
-        logger.info(`Resource requested: ${uri}`);
-        try {
-            let content = null;
-            let mimeType = "text/plain";
-            if (uri.startsWith("midnight://docs/")) {
-                content = await getDocumentation(uri);
-                mimeType = "text/markdown";
-            }
-            else if (uri.startsWith("midnight://code/")) {
-                content = await getCode(uri);
-                mimeType = "text/x-compact";
-            }
-            else if (uri.startsWith("midnight://schema/")) {
-                const schema = getSchema(uri);
-                content = schema ? JSON.stringify(schema, null, 2) : null;
-                mimeType = "application/json";
-            }
-            if (!content) {
-                const resourceTypes = [
-                    "midnight://docs/",
-                    "midnight://code/",
-                    "midnight://schema/",
-                ];
-                const validPrefix = resourceTypes.find((p) => uri.startsWith(p));
-                return {
-                    contents: [
-                        {
-                            uri,
-                            mimeType: "application/json",
-                            text: JSON.stringify({
-                                error: `Resource not found: ${uri}`,
-                                suggestion: validPrefix
-                                    ? `Check the resource path after '${validPrefix}'`
-                                    : `Valid resource prefixes: ${resourceTypes.join(", ")}`,
-                                hint: "Use ListResources to see all available resources",
-                            }, null, 2),
-                        },
-                    ],
-                };
-            }
-            return {
-                contents: [
-                    {
-                        uri,
-                        mimeType,
-                        text: content,
-                    },
-                ],
-            };
-        }
-        catch (error) {
-            logger.error(`Resource error: ${uri}`, { error: String(error) });
-            const errorResponse = formatErrorResponse(error, `resource:${uri}`);
-            return {
-                contents: [
-                    {
-                        uri,
-                        mimeType: "application/json",
-                        text: JSON.stringify(errorResponse, null, 2),
-                    },
-                ],
-            };
-        }
-    });
-}
-/**
- * Register prompt handlers
- */
-function registerPromptHandlers(server) {
-    // List available prompts
-    server.setRequestHandler(ListPromptsRequestSchema, async () => {
-        logger.debug("Listing prompts");
-        return {
-            prompts: promptDefinitions.map((prompt) => ({
-                name: prompt.name,
-                description: prompt.description,
-                arguments: prompt.arguments,
-            })),
-        };
-    });
-    // Get prompt content
-    server.setRequestHandler(GetPromptRequestSchema, async (request) => {
-        const { name, arguments: args } = request.params;
-        logger.info(`Prompt requested: ${name}`, { args });
-        const prompt = promptDefinitions.find((p) => p.name === name);
-        if (!prompt) {
-            return {
-                description: `Unknown prompt: ${name}`,
-                messages: [],
-            };
-        }
-        const messages = generatePrompt(name, args || {});
-        return {
-            description: prompt.description,
-            messages: messages.map((m) => ({
-                role: m.role,
-                content: m.content,
-            })),
-        };
-    });
-}
-/**
- * Register resource subscription handlers
- */
-function registerSubscriptionHandlers(server) {
-    // Handle subscribe requests
-    server.setRequestHandler(SubscribeRequestSchema, async (request) => {
-        const { uri } = request.params;
-        logger.info(`Subscribing to resource: ${uri}`);
-        // Validate that the URI is a valid resource
-        const validPrefixes = [
-            "midnight://docs/",
-            "midnight://code/",
-            "midnight://schema/",
-        ];
-        const isValid = validPrefixes.some((prefix) => uri.startsWith(prefix));
-        if (!isValid) {
-            logger.warn(`Invalid subscription URI: ${uri}`);
-            throw new Error(`Invalid subscription URI: ${uri}. Valid prefixes: ${validPrefixes.join(", ")}`);
-        }
-        resourceSubscriptions.add(uri);
-        logger.debug(`Active subscriptions: ${resourceSubscriptions.size}`);
-        return {};
-    });
-    // Handle unsubscribe requests
-    server.setRequestHandler(UnsubscribeRequestSchema, async (request) => {
-        const { uri } = request.params;
-        logger.info(`Unsubscribing from resource: ${uri}`);
-        resourceSubscriptions.delete(uri);
-        logger.debug(`Active subscriptions: ${resourceSubscriptions.size}`);
-        return {};
-    });
-}
-/**
- * Notify subscribers when a resource changes
- * Call this when re-indexing or when docs are updated
- */
-export function notifyResourceUpdate(server, uri) {
-    if (resourceSubscriptions.has(uri)) {
-        logger.info(`Notifying subscribers of update: ${uri}`);
-        // Send notification via the server
-        server.notification({
-            method: "notifications/resources/updated",
-            params: { uri },
-        });
-    }
-}
-/**
- * Get the list of active subscriptions
- */
-export function getActiveSubscriptions() {
-    return Array.from(resourceSubscriptions);
-}
-/**
- * Setup sampling capability
- * Registers a callback that allows the server to request LLM completions
- */
-function setupSampling(server) {
-    // Create a sampling callback that uses the server's request method
-    const samplingCallback = async (request) => {
-        logger.debug("Requesting sampling from client", {
-            messageCount: request.messages.length,
-            maxTokens: request.maxTokens,
-        });
-        try {
-            // Request completion from the client
-            const response = await server.request({
-                method: "sampling/createMessage",
-                params: {
-                    messages: request.messages,
-                    systemPrompt: request.systemPrompt,
-                    maxTokens: request.maxTokens || 2048,
-                    temperature: request.temperature,
-                    modelPreferences: request.modelPreferences,
-                },
-            }, 
-            // Use a schema that matches the expected response
-            {
-                parse: (data) => {
-                    const response = data;
-                    // Basic validation of expected response structure
-                    if (!response || typeof response !== "object") {
-                        throw new Error("Invalid sampling response: expected object");
-                    }
-                    if (!response.content || typeof response.content !== "object") {
-                        throw new Error("Invalid sampling response: missing content");
-                    }
-                    return response;
-                },
-                _def: { typeName: "SamplingResponse" },
-            });
-            return response;
-        }
-        catch (error) {
-            logger.error("Sampling request failed", { error: String(error) });
-            throw error;
-        }
-    };
-    // Register the callback
-    registerSamplingCallback(samplingCallback);
-    logger.info("Sampling capability configured");
-}
-/**
- * Initialize the server and vector store
- */
-export async function initializeServer() {
-    logger.info("Initializing Midnight MCP Server...");
-    // Check for updates in background (non-blocking)
-    checkForUpdates().catch(() => {
-        // Ignore errors - version check is best-effort
-    });
-    // Initialize vector store
-    try {
-        await vectorStore.initialize();
-        logger.info("Vector store initialized");
-    }
-    catch (error) {
-        logger.warn("Vector store initialization failed, continuing without it", {
-            error: String(error),
-        });
-    }
-    // Create and return server
-    const server = createServer();
-    logger.info(`Server v${CURRENT_VERSION} created successfully`);
-    return server;
-}
-/**
- * Start the server with stdio transport
- */
-export async function startServer() {
-    const server = await initializeServer();
-    const transport = new StdioServerTransport();
-    await server.connect(transport);
-    // Now safe to send notifications
-    setServerConnected(true);
-    logger.info("Midnight MCP Server running on stdio");
-}
-//# sourceMappingURL=server.js.map

package/dist/services/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Services index
- * Export all service modules
- */
-export { isSamplingAvailable, registerSamplingCallback, requestCompletion, generateContract, reviewContract, generateDocumentation, } from "./sampling.js";
-//# sourceMappingURL=index.d.ts.map