midnight-mcp 0.0.5 → 0.0.7

package/README.md

@@ -1,9 +1,15 @@
 # Midnight MCP Server
 
+[![npm version](https://badge.fury.io/js/midnight-mcp.svg)](https://www.npmjs.com/package/midnight-mcp)
+[![Index Repositories](https://github.com/Olanetsoft/midnight-mcp/actions/workflows/index.yml/badge.svg)](https://github.com/Olanetsoft/midnight-mcp/actions/workflows/index.yml)
+[![CI](https://github.com/Olanetsoft/midnight-mcp/actions/workflows/ci.yml/badge.svg)](https://github.com/Olanetsoft/midnight-mcp/actions/workflows/ci.yml)
+
 MCP server that gives AI assistants access to Midnight blockchain—search contracts, analyze code, and explore documentation.
 
 ## Quick Start
 
+### Claude Desktop
+
 Add to your `claude_desktop_config.json`:
 
 ```json
@@ -17,7 +23,61 @@ Add to your `claude_desktop_config.json`:
 }
 ```
 
-Restart Claude Desktop. All features work out of the box—no API keys or setup required.
+<details>
+<summary><strong>📍 Config file locations</strong></summary>
+
+- **macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`
+- **Windows**: `%APPDATA%\Claude\claude_desktop_config.json`
+- **Linux**: `~/.config/Claude/claude_desktop_config.json`
+
+</details>
+
+### Cursor
+
+Add to Cursor's MCP settings (Settings → MCP → Add Server):
+
+```json
+{
+  "mcpServers": {
+    "midnight": {
+      "command": "npx",
+      "args": ["-y", "midnight-mcp"]
+    }
+  }
+}
+```
+
+Or add to `.cursor/mcp.json` in your project:
+
+```json
+{
+  "mcpServers": {
+    "midnight": {
+      "command": "npx",
+      "args": ["-y", "midnight-mcp"]
+    }
+  }
+}
+```
+
+### Windsurf
+
+Add to `~/.codeium/windsurf/mcp_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "midnight": {
+      "command": "npx",
+      "args": ["-y", "midnight-mcp"]
+    }
+  }
+}
+```
+
+---
+
+Restart your editor after adding the config. All features work out of the box—no API keys or setup required.
 
 ---
 
@@ -86,13 +146,13 @@ Add `"GITHUB_TOKEN": "ghp_..."` for higher GitHub API rate limits (60 → 5000 r
 - `midnight://code/*` — Examples, patterns, and templates
 - `midnight://schema/*` — AST, transaction, and proof schemas
 
-### Prompts
+### Prompts (5)
 
-- `midnight-create-contract` — Create new contracts
-- `midnight-review-contract` — Security review
-- `midnight-explain-concept` — Learn Midnight concepts
-- `midnight-compare-approaches` — Compare implementation approaches
-- `midnight-debug-contract` — Debug issues
+- `midnight:create-contract` — Create new contracts
+- `midnight:review-contract` — Security review
+- `midnight:explain-concept` — Learn Midnight concepts
+- `midnight:compare-approaches` — Compare implementation approaches
+- `midnight:debug-contract` — Debug issues
 
 ---
 

package/dist/tools/search.js

@@ -1,6 +1,86 @@
 import { z } from "zod";
 import { vectorStore } from "../db/index.js";
 import { logger, validateQuery, validateNumber, searchCache, createCacheKey, isHostedMode, searchCompactHosted, searchTypeScriptHosted, searchDocsHosted, } from "../utils/index.js";
+/**
+ * Validate and prepare common search parameters
+ * Extracts common validation logic used by all search functions
+ */
+function validateSearchInput(query, limit) {
+    const queryValidation = validateQuery(query);
+    if (!queryValidation.isValid) {
+        return {
+            success: false,
+            error: {
+                error: "Invalid query",
+                details: queryValidation.errors,
+                suggestion: "Provide a valid search query with at least 2 characters",
+            },
+        };
+    }
+    const limitValidation = validateNumber(limit, {
+        min: 1,
+        max: 50,
+        defaultValue: 10,
+    });
+    return {
+        success: true,
+        context: {
+            sanitizedQuery: queryValidation.sanitized,
+            limit: limitValidation.value,
+            warnings: queryValidation.warnings,
+        },
+    };
+}
+/**
+ * Check cache for existing search results
+ */
+function checkSearchCache(cacheKey) {
+    const cached = searchCache.get(cacheKey);
+    if (cached) {
+        logger.debug("Search cache hit", { cacheKey });
+        return cached;
+    }
+    return null;
+}
+/**
+ * Execute hosted search with fallback handling
+ */
+async function tryHostedSearch(searchType, hostedSearchFn, cacheKey, warnings) {
+    if (!isHostedMode()) {
+        return null;
+    }
+    try {
+        const response = await hostedSearchFn();
+        searchCache.set(cacheKey, response);
+        return {
+            result: {
+                ...response,
+                ...(warnings.length > 0 && { warnings }),
+            },
+            cached: true,
+        };
+    }
+    catch (error) {
+        logger.warn(`Hosted API ${searchType} search failed, falling back to local`, {
+            error: String(error),
+        });
+        return null;
+    }
+}
+/**
+ * Add warnings to response and cache it
+ */
+function finalizeResponse(response, cacheKey, warnings) {
+    const finalResponse = {
+        ...response,
+        ...(warnings.length > 0 && { warnings }),
+    };
+    searchCache.set(cacheKey, finalResponse);
+    return finalResponse;
+}
+// ============================================================================
+// Schema Definitions
+// ============================================================================
 // Schema definitions for tool inputs
 export const SearchCompactInputSchema = z.object({
     query: z.string().describe("Natural language search query for Compact code"),
@@ -44,52 +124,25 @@ export const SearchDocsInputSchema = z.object({
  * Search Compact smart contract code and patterns
  */
 export async function searchCompact(input) {
-    // Validate input
-    const queryValidation = validateQuery(input.query);
-    if (!queryValidation.isValid) {
-        return {
-            error: "Invalid query",
-            details: queryValidation.errors,
-            suggestion: "Provide a valid search query with at least 2 characters",
-        };
+    // Validate input using common helper
+    const validation = validateSearchInput(input.query, input.limit);
+    if (!validation.success) {
+        return validation.error;
     }
-    const limitValidation = validateNumber(input.limit, {
-        min: 1,
-        max: 50,
-        defaultValue: 10,
-    });
-    const sanitizedQuery = queryValidation.sanitized;
-    const limit = limitValidation.value;
+    const { sanitizedQuery, limit, warnings } = validation.context;
     logger.debug("Searching Compact code", {
         query: sanitizedQuery,
         mode: isHostedMode() ? "hosted" : "local",
     });
     // Check cache first
     const cacheKey = createCacheKey("compact", sanitizedQuery, limit, input.filter?.repository);
-    const cached = searchCache.get(cacheKey);
-    if (cached) {
-        logger.debug("Search cache hit", { cacheKey });
+    const cached = checkSearchCache(cacheKey);
+    if (cached)
         return cached;
-    }
-    // Use hosted API if in hosted mode
-    if (isHostedMode()) {
-        try {
-            const response = await searchCompactHosted(sanitizedQuery, limit);
-            searchCache.set(cacheKey, response);
-            return {
-                ...response,
-                ...(queryValidation.warnings.length > 0 && {
-                    warnings: queryValidation.warnings,
-                }),
-            };
-        }
-        catch (error) {
-            logger.warn("Hosted API search failed, falling back to local", {
-                error: String(error),
-            });
-            // Fall through to local search
-        }
-    }
+    // Try hosted API first
+    const hostedResult = await tryHostedSearch("compact", () => searchCompactHosted(sanitizedQuery, limit), cacheKey, warnings);
+    if (hostedResult)
+        return hostedResult.result;
     // Local search (fallback or when in local mode)
     const filter = {
         language: "compact",
@@ -110,64 +163,32 @@ export async function searchCompact(input) {
         })),
         totalResults: results.length,
         query: sanitizedQuery,
-        ...(queryValidation.warnings.length > 0 && {
-            warnings: queryValidation.warnings,
-        }),
     };
-    // Cache the response
-    searchCache.set(cacheKey, response);
-    return response;
+    return finalizeResponse(response, cacheKey, warnings);
 }
 /**
  * Search TypeScript SDK code, types, and API implementations
  */
 export async function searchTypeScript(input) {
-    // Validate input
-    const queryValidation = validateQuery(input.query);
-    if (!queryValidation.isValid) {
-        return {
-            error: "Invalid query",
-            details: queryValidation.errors,
-            suggestion: "Provide a valid search query with at least 2 characters",
-        };
+    // Validate input using common helper
+    const validation = validateSearchInput(input.query, input.limit);
+    if (!validation.success) {
+        return validation.error;
     }
-    const limitValidation = validateNumber(input.limit, {
-        min: 1,
-        max: 50,
-        defaultValue: 10,
-    });
-    const sanitizedQuery = queryValidation.sanitized;
-    const limit = limitValidation.value;
+    const { sanitizedQuery, limit, warnings } = validation.context;
     logger.debug("Searching TypeScript code", {
         query: sanitizedQuery,
         mode: isHostedMode() ? "hosted" : "local",
     });
     // Check cache
     const cacheKey = createCacheKey("typescript", sanitizedQuery, limit, input.includeTypes, input.includeExamples);
-    const cached = searchCache.get(cacheKey);
-    if (cached) {
-        logger.debug("Search cache hit", { cacheKey });
+    const cached = checkSearchCache(cacheKey);
+    if (cached)
         return cached;
-    }
-    // Use hosted API if in hosted mode
-    if (isHostedMode()) {
-        try {
-            const response = await searchTypeScriptHosted(sanitizedQuery, limit, input.includeTypes);
-            searchCache.set(cacheKey, response);
-            return {
-                ...response,
-                ...(queryValidation.warnings.length > 0 && {
-                    warnings: queryValidation.warnings,
-                }),
-            };
-        }
-        catch (error) {
-            logger.warn("Hosted API search failed, falling back to local", {
-                error: String(error),
-            });
-            // Fall through to local search
-        }
-    }
+    // Try hosted API first
+    const hostedResult = await tryHostedSearch("typescript", () => searchTypeScriptHosted(sanitizedQuery, limit, input.includeTypes), cacheKey, warnings);
+    if (hostedResult)
+        return hostedResult.result;
     // Local search (fallback or when in local mode)
     const filter = {
         language: "typescript",
@@ -193,63 +214,32 @@ export async function searchTypeScript(input) {
         })),
         totalResults: filteredResults.length,
         query: sanitizedQuery,
-        ...(queryValidation.warnings.length > 0 && {
-            warnings: queryValidation.warnings,
-        }),
     };
-    searchCache.set(cacheKey, response);
-    return response;
+    return finalizeResponse(response, cacheKey, warnings);
 }
 /**
  * Full-text search across official Midnight documentation
  */
 export async function searchDocs(input) {
-    // Validate input
-    const queryValidation = validateQuery(input.query);
-    if (!queryValidation.isValid) {
-        return {
-            error: "Invalid query",
-            details: queryValidation.errors,
-            suggestion: "Provide a valid search query with at least 2 characters",
-        };
+    // Validate input using common helper
+    const validation = validateSearchInput(input.query, input.limit);
+    if (!validation.success) {
+        return validation.error;
     }
-    const limitValidation = validateNumber(input.limit, {
-        min: 1,
-        max: 50,
-        defaultValue: 10,
-    });
-    const sanitizedQuery = queryValidation.sanitized;
-    const limit = limitValidation.value;
+    const { sanitizedQuery, limit, warnings } = validation.context;
     logger.debug("Searching documentation", {
         query: sanitizedQuery,
         mode: isHostedMode() ? "hosted" : "local",
     });
     // Check cache
     const cacheKey = createCacheKey("docs", sanitizedQuery, limit, input.category);
-    const cached = searchCache.get(cacheKey);
-    if (cached) {
-        logger.debug("Search cache hit", { cacheKey });
+    const cached = checkSearchCache(cacheKey);
+    if (cached)
         return cached;
-    }
-    // Use hosted API if in hosted mode
-    if (isHostedMode()) {
-        try {
-            const response = await searchDocsHosted(sanitizedQuery, limit, input.category);
-            searchCache.set(cacheKey, response);
-            return {
-                ...response,
-                ...(queryValidation.warnings.length > 0 && {
-                    warnings: queryValidation.warnings,
-                }),
-            };
-        }
-        catch (error) {
-            logger.warn("Hosted API search failed, falling back to local", {
-                error: String(error),
-            });
-            // Fall through to local search
-        }
-    }
+    // Try hosted API first
+    const hostedResult = await tryHostedSearch("docs", () => searchDocsHosted(sanitizedQuery, limit, input.category), cacheKey, warnings);
+    if (hostedResult)
+        return hostedResult.result;
     // Local search (fallback or when in local mode)
     const filter = {
         language: "markdown",
@@ -273,12 +263,8 @@ export async function searchDocs(input) {
         totalResults: results.length,
         query: sanitizedQuery,
         category: input.category,
-        ...(queryValidation.warnings.length > 0 && {
-            warnings: queryValidation.warnings,
-        }),
     };
-    searchCache.set(cacheKey, response);
-    return response;
+    return finalizeResponse(response, cacheKey, warnings);
 }
 // Tool definitions for MCP
 export const searchTools = [

package/dist/utils/errors.js

@@ -69,8 +69,8 @@ export function createUserError(error, context) {
         return new MCPError(`OpenAI API error${ctx}`, ErrorCodes.OPENAI_UNAVAILABLE, "OpenAI is optional. Without it, search uses keyword matching. " +
             "To enable semantic search, add OPENAI_API_KEY to your config.");
     }
-    // Default error
-    return new MCPError(`An error occurred${ctx}: ${message}`, "UNKNOWN_ERROR", "If this problem persists, please report it at https://github.com/Olanetsoft/midnight-mcp/issues");
+    // Default error - don't leak internal details
+    return new MCPError(`An error occurred${ctx}`, "UNKNOWN_ERROR", "If this problem persists, please report it at https://github.com/Olanetsoft/midnight-mcp/issues");
 }
 /**
  * Format error for MCP response

package/dist/utils/hosted-api.d.ts

@@ -22,6 +22,7 @@ export interface HostedSearchResponse {
     query: string;
     category?: string;
     warnings?: string[];
+    lastIndexed?: string | null;
 }
 export interface HostedSearchFilter {
     language?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "midnight-mcp",
-  "version": "0.0.5",
+  "version": "0.0.7",
   "description": "Model Context Protocol Server for Midnight Blockchain Development",
   "type": "module",
   "main": "dist/index.js",
@@ -13,7 +13,6 @@
     "dev": "tsx watch src/index.ts",
     "test": "vitest",
     "test:coverage": "vitest --coverage",
-    "lint": "eslint src/**/*.ts",
     "format": "prettier --write src/**/*.ts",
     "prepublishOnly": "npm run build"
   },