midnight-mcp 0.1.29 → 0.1.30

package/README.md

@@ -105,6 +105,18 @@ npx clear-npx-cache
 
 All tools are prefixed with `midnight-` (e.g., `midnight-search-compact`).
 
+### MCP Capabilities
+
+| Capability      | Feature                                         |
+| --------------- | ----------------------------------------------- |
+| **Tools**       | 25 tools with `listChanged` notifications       |
+| **Resources**   | 9 embedded resources with subscription support  |
+| **Prompts**     | 5 workflow prompts                              |
+| **Logging**     | Client-controllable log level                   |
+| **Completions** | Autocomplete for prompt arguments               |
+| **Progress**    | Real-time progress for compound tools           |
+| **Sampling**    | AI-powered generation (when client supports it) |
+
 ### 9 Embedded Resources
 
 Quick references available offline:

package/dist/server.d.ts

@@ -1,4 +1,5 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { LoggingLevel } from "@modelcontextprotocol/sdk/types.js";
 /**
  * Get update warning if outdated (to include in responses)
  */
@@ -8,8 +9,15 @@ export declare function getUpdateWarning(): string | null;
  */
 export declare function clearSubscriptions(): void;
 /**
- * Create and configure the MCP server
+ * Send a log message to the MCP client
+ * This allows clients to see server logs for debugging
  */
+export declare function sendLogToClient(level: LoggingLevel, loggerName: string, data: unknown): void;
+/**
+ * Send a progress notification to the MCP client
+ * Used for long-running operations like compound tools
+ */
+export declare function sendProgressNotification(progressToken: string | number, progress: number, total?: number, message?: string): void;
 export declare function createServer(): Server;
 /**
  * Notify subscribers when a resource changes

package/dist/server.js

@@ -1,14 +1,14 @@
 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, } from "@modelcontextprotocol/sdk/types.js";
-import { logger, formatErrorResponse } from "./utils/index.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, ListResourcesRequestSchema, ReadResourceRequestSchema, ListPromptsRequestSchema, GetPromptRequestSchema, ListResourceTemplatesRequestSchema, SubscribeRequestSchema, UnsubscribeRequestSchema, SetLevelRequestSchema, CompleteRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { logger, formatErrorResponse, setMCPLogCallback, } 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";
 // Server information - version should match package.json
-const CURRENT_VERSION = "0.1.29";
+const CURRENT_VERSION = "0.1.30";
 const SERVER_INFO = {
     name: "midnight-mcp",
     version: CURRENT_VERSION,
@@ -97,6 +97,67 @@ const resourceTemplates = [
 /**
  * Create and configure the MCP server
  */
+// Current MCP logging level (controlled by client)
+let mcpLogLevel = "info";
+// Server instance for sending notifications
+let serverInstance = null;
+/**
+ * Send a log message to the MCP client
+ * This allows clients to see server logs for debugging
+ */
+export function sendLogToClient(level, loggerName, data) {
+    if (!serverInstance)
+        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: {
@@ -110,8 +171,16 @@ export function createServer() {
             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
@@ -120,10 +189,114 @@ export function createServer() {
     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
  */
@@ -207,6 +380,9 @@ function registerToolHandlers(server) {
                         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) {

package/dist/tools/repository/handlers.d.ts

@@ -191,7 +191,11 @@ export declare function getLatestSyntax(input: GetLatestSyntaxInput): Promise<{
  * Combines: getVersionInfo + checkBreakingChanges + getMigrationGuide
  * Reduces 3 tool calls to 1, saving ~60% tokens
  */
-export declare function upgradeCheck(input: UpgradeCheckInput): Promise<{
+export declare function upgradeCheck(input: UpgradeCheckInput & {
+    _meta?: {
+        progressToken?: string | number;
+    };
+}): Promise<{
     repository: string;
     currentVersion: string;
     version: {
@@ -219,7 +223,11 @@ export declare function upgradeCheck(input: UpgradeCheckInput): Promise<{
  * Combines: getVersionInfo + getLatestSyntax + listExamples (filtered)
  * Provides everything needed to start working with a repo
  */
-export declare function getFullRepoContext(input: FullRepoContextInput): Promise<{
+export declare function getFullRepoContext(input: FullRepoContextInput & {
+    _meta?: {
+        progressToken?: string | number;
+    };
+}): Promise<{
     repository: string;
     quickStart: {
         version: string;

package/dist/tools/repository/handlers.js

@@ -5,6 +5,7 @@
 import { githubClient } from "../../pipeline/index.js";
 import { releaseTracker } from "../../pipeline/releases.js";
 import { logger, DEFAULT_REPOSITORIES, SelfCorrectionHints, } from "../../utils/index.js";
+import { sendProgressNotification } from "../../server.js";
 import { REPO_ALIASES, EXAMPLES } from "./constants.js";
 import { EMBEDDED_DOCS } from "../../resources/content/docs-content.js";
 // Re-export validation handlers from validation.ts
@@ -399,6 +400,7 @@ export async function getLatestSyntax(input) {
 export async function upgradeCheck(input) {
     const repoName = input?.repo || "compact";
     const currentVersion = input.currentVersion;
+    const progressToken = input._meta?.progressToken;
     logger.debug("Running compound upgrade check", {
         repo: repoName,
         currentVersion,
@@ -407,18 +409,34 @@ export async function upgradeCheck(input) {
     if (!resolved) {
         throw new Error(`Unknown repository: ${repoName}. Available: ${Object.keys(REPO_ALIASES).join(", ")}`);
     }
+    // Send progress: Starting
+    if (progressToken) {
+        sendProgressNotification(progressToken, 1, 4, "Fetching version info...");
+    }
     // Fetch all data in parallel
     const [versionInfo, outdatedInfo, breakingChanges] = await Promise.all([
         releaseTracker.getVersionInfo(resolved.owner, resolved.repo),
         releaseTracker.isOutdated(resolved.owner, resolved.repo, currentVersion),
         releaseTracker.getBreakingChangesSince(resolved.owner, resolved.repo, currentVersion),
     ]);
+    // Send progress: Fetched version data
+    if (progressToken) {
+        sendProgressNotification(progressToken, 2, 4, "Checking breaking changes...");
+    }
     const latestVersion = versionInfo.latestStableRelease?.tag || versionInfo.latestRelease?.tag;
     // Only fetch migration guide if there are breaking changes
     let migrationGuide = null;
     if (breakingChanges.length > 0 && latestVersion) {
+        // Send progress: Fetching migration guide
+        if (progressToken) {
+            sendProgressNotification(progressToken, 3, 4, "Generating migration guide...");
+        }
         migrationGuide = await releaseTracker.getMigrationGuide(resolved.owner, resolved.repo, currentVersion, latestVersion);
     }
+    // Send progress: Complete
+    if (progressToken) {
+        sendProgressNotification(progressToken, 4, 4, "Analysis complete");
+    }
     // Compute upgrade urgency
     const urgency = computeUpgradeUrgency(outdatedInfo, breakingChanges.length);
     return {
@@ -458,21 +476,34 @@ export async function upgradeCheck(input) {
  */
 export async function getFullRepoContext(input) {
     const repoName = input?.repo || "compact";
+    const progressToken = input._meta?.progressToken;
     logger.debug("Getting full repo context", { repo: repoName });
     const resolved = resolveRepo(repoName);
     if (!resolved) {
         throw new Error(`Unknown repository: ${repoName}. Available: ${Object.keys(REPO_ALIASES).join(", ")}`);
     }
+    // Send progress: Starting
+    if (progressToken) {
+        sendProgressNotification(progressToken, 1, 4, "Fetching version info...");
+    }
     // Fetch version info
     const versionInfo = await releaseTracker.getVersionInfo(resolved.owner, resolved.repo);
     const version = versionInfo.latestStableRelease?.tag ||
         versionInfo.latestRelease?.tag ||
         "main";
+    // Send progress: Fetched version
+    if (progressToken) {
+        sendProgressNotification(progressToken, 2, 4, "Loading syntax reference...");
+    }
     // Conditionally fetch syntax reference
     let syntaxRef = null;
     if (input.includeSyntax !== false) {
         syntaxRef = await releaseTracker.getLatestSyntaxReference(resolved.owner, resolved.repo);
     }
+    // Send progress: Loading examples
+    if (progressToken) {
+        sendProgressNotification(progressToken, 3, 4, "Gathering examples...");
+    }
     // Get relevant examples for this repo
     let examples = [];
     if (input.includeExamples !== false) {
@@ -486,6 +517,10 @@ export async function getFullRepoContext(input) {
             complexity: ex.complexity,
         }));
     }
+    // Send progress: Complete
+    if (progressToken) {
+        sendProgressNotification(progressToken, 4, 4, "Context ready");
+    }
     return {
         repository: `${resolved.owner}/${resolved.repo}`,
         // Quick start info

package/dist/utils/index.d.ts

@@ -1,7 +1,7 @@
 export { config, isHostedMode, isLocalMode } from "./config.js";
 export type { Config, RepositoryConfig } from "./config.js";
 export { DEFAULT_REPOSITORIES } from "./config.js";
-export { logger } from "./logger.js";
+export { logger, setMCPLogCallback } from "./logger.js";
 export { MCPError, ErrorCodes, createUserError, formatErrorResponse, withErrorHandling, SelfCorrectionHints, } from "./errors.js";
 export { validateQuery, validateRepository, validatePath, validateRef, validateNumber, validateToolArgs, sanitizeString, } from "./validation.js";
 export type { ValidationResult } from "./validation.js";

package/dist/utils/index.js

@@ -1,6 +1,6 @@
 export { config, isHostedMode, isLocalMode } from "./config.js";
 export { DEFAULT_REPOSITORIES } from "./config.js";
-export { logger } from "./logger.js";
+export { logger, setMCPLogCallback } from "./logger.js";
 export { MCPError, ErrorCodes, createUserError, formatErrorResponse, withErrorHandling, SelfCorrectionHints, } from "./errors.js";
 // Validation utilities
 export { validateQuery, validateRepository, validatePath, validateRef, validateNumber, validateToolArgs, sanitizeString, } from "./validation.js";

package/dist/utils/logger.d.ts

@@ -1,5 +1,10 @@
 type LogLevel = "debug" | "info" | "warn" | "error";
 type LogFormat = "text" | "json";
+type MCPLogCallback = (level: "debug" | "info" | "notice" | "warning" | "error", logger: string, data: unknown) => void;
+/**
+ * Set the MCP log callback to send logs to the client
+ */
+export declare function setMCPLogCallback(callback: MCPLogCallback | null): void;
 declare class Logger {
     private level;
     private format;

package/dist/utils/logger.js

@@ -1,4 +1,12 @@
 import { config } from "./config.js";
+// Global MCP log callback (set by server)
+let mcpLogCallback = null;
+/**
+ * Set the MCP log callback to send logs to the client
+ */
+export function setMCPLogCallback(callback) {
+    mcpLogCallback = callback;
+}
 const LOG_LEVELS = {
     debug: 0,
     info: 1,
@@ -56,21 +64,29 @@ class Logger {
         if (this.shouldLog("debug")) {
             console.error(this.formatMessage("debug", message, meta));
         }
+        // Also send to MCP client
+        mcpLogCallback?.("debug", this.service, { message, ...meta });
     }
     info(message, meta) {
         if (this.shouldLog("info")) {
             console.error(this.formatMessage("info", message, meta));
         }
+        // Also send to MCP client
+        mcpLogCallback?.("info", this.service, { message, ...meta });
     }
     warn(message, meta) {
         if (this.shouldLog("warn")) {
             console.error(this.formatMessage("warn", message, meta));
         }
+        // Also send to MCP client (MCP uses "warning" not "warn")
+        mcpLogCallback?.("warning", this.service, { message, ...meta });
     }
     error(message, meta) {
         if (this.shouldLog("error")) {
             console.error(this.formatMessage("error", message, meta));
         }
+        // Also send to MCP client
+        mcpLogCallback?.("error", this.service, { message, ...meta });
     }
     /**
      * Create a child logger with additional context

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midnight-mcp",
-  "version": "0.1.29",
+  "version": "0.1.30",
   "description": "Model Context Protocol Server for Midnight Blockchain Development",
   "type": "module",
   "main": "dist/index.js",