midnight-mcp 0.2.13 → 0.2.14

package/README.md

@@ -104,12 +104,12 @@ Add to `~/.codeium/windsurf/mcp_config.json`:
 
 ## What's Included
 
-### 28 Tools
+### 29 Tools
 
 | Category          | Tools                                                                                                                             | Description                                      |
 | ----------------- | --------------------------------------------------------------------------------------------------------------------------------- | ------------------------------------------------ |
 | **Search**        | `search-compact`, `search-typescript`, `search-docs`, `fetch-docs`                                                                | Semantic search + live docs fetching             |
-| **Analysis**      | `analyze-contract`, `explain-circuit`, `extract-contract-structure`                                                               | Static analysis with 15+ checks (P0-P2 severity) |
+| **Analysis**      | `analyze-contract`, `explain-circuit`, `extract-contract-structure`, `compile-contract`                                           | Static analysis + real compilation               |
 | **Repository**    | `get-file`, `list-examples`, `get-latest-updates`                                                                                 | Access files and examples                        |
 | **Versioning**    | `get-version-info`, `check-breaking-changes`, `get-migration-guide`, `get-file-at-version`, `compare-syntax`, `get-latest-syntax` | Version tracking and migration                   |
 | **AI Generation** | `generate-contract`, `review-contract`, `document-contract`                                                                       | AI-powered code generation _(requires sampling)_ |
@@ -119,6 +119,20 @@ Add to `~/.codeium/windsurf/mcp_config.json`:
 
 All tools are prefixed with `midnight-` (e.g., `midnight-search-compact`).
 
+### Real Contract Compilation
+
+The `midnight-compile-contract` tool validates Compact code using a hosted compiler service:
+
+```
+✅ Compilation successful (Compiler v0.18.0) in 2841ms
+```
+
+- **Fast mode** (`skipZk=true`): Syntax validation in ~1-2 seconds
+- **Full mode** (`fullCompile=true`): Complete ZK circuit generation in ~10-30 seconds
+- **Automatic fallback**: Falls back to static analysis if the compiler service is unavailable
+
+This catches semantic errors that static analysis misses (sealed fields, disclose rules, type mismatches).
+
 ### MCP Capabilities
 
 | Capability      | Feature                                         |

package/dist/bin.js

@@ -2,10 +2,10 @@
 import {
   startHttpServer,
   startServer
-} from "./chunk-LXHUX67Z.js";
+} from "./chunk-V7KK64OX.js";
 import {
   setOutputFormat
-} from "./chunk-FZI3KN52.js";
+} from "./chunk-WYQRVPIQ.js";
 
 // src/bin.ts
 import { config } from "dotenv";
@@ -13,7 +13,7 @@ import { resolve } from "path";
 import yargs from "yargs";
 import { hideBin } from "yargs/helpers";
 config({ path: resolve(process.cwd(), ".env") });
-var CURRENT_VERSION = "0.2.13";
+var CURRENT_VERSION = "0.2.14";
 process.on("uncaughtException", (error) => {
   console.error("Uncaught exception:", error);
   process.exit(1);

package/dist/{chunk-LXHUX67Z.js → chunk-V7KK64OX.js}

@@ -25,7 +25,7 @@ import {
   validateNumber,
   validateQuery,
   vectorStore
-} from "./chunk-FZI3KN52.js";
+} from "./chunk-WYQRVPIQ.js";
 
 // src/tools/search/schemas.ts
 import { z } from "zod";
@@ -733,6 +733,144 @@ var AnalyzeContractInputSchema = z2.object({
 var ExplainCircuitInputSchema = z2.object({
   circuitCode: z2.string().describe("Circuit definition from Compact")
 });
+var CompileContractInputSchema = z2.object({
+  code: z2.string().describe("Compact contract source code to compile"),
+  skipZk: z2.boolean().optional().default(true).describe(
+    "Skip ZK circuit generation for faster syntax-only validation (default: true)"
+  ),
+  fullCompile: z2.boolean().optional().default(false).describe(
+    "Perform full compilation including ZK generation (slower but complete)"
+  )
+});
+
+// src/services/compiler.ts
+var COMPILER_API_URL = process.env.COMPACT_COMPILER_URL || "https://compact-playground.onrender.com";
+var COMPILER_TIMEOUT = 3e4;
+var MAX_CODE_SIZE = 100 * 1024;
+async function compileContract(code, options = {}) {
+  if (!code || typeof code !== "string") {
+    return {
+      success: false,
+      message: "No code provided",
+      error: "INVALID_INPUT",
+      serviceAvailable: true
+    };
+  }
+  if (code.length > MAX_CODE_SIZE) {
+    return {
+      success: false,
+      message: `Code exceeds maximum size of ${MAX_CODE_SIZE / 1024}KB`,
+      error: "CODE_TOO_LARGE",
+      serviceAvailable: true
+    };
+  }
+  try {
+    const controller = new AbortController();
+    const timeoutId = setTimeout(() => controller.abort(), COMPILER_TIMEOUT);
+    const requestBody = {
+      code,
+      options: {
+        wrapWithDefaults: options.wrapWithDefaults ?? true,
+        skipZk: options.skipZk ?? true
+        // Default to fast syntax-only validation
+      }
+    };
+    logger.info("Sending code to compiler service", {
+      codeLength: code.length,
+      options: requestBody.options
+    });
+    const response = await fetch(`${COMPILER_API_URL}/compile`, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify(requestBody),
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    if (!response.ok) {
+      const errorText = await response.text().catch(() => "Unknown error");
+      logger.error("Compiler API returned error status", {
+        status: response.status,
+        error: errorText
+      });
+      return {
+        success: false,
+        message: `Compiler service error: ${response.status}`,
+        error: "API_ERROR",
+        serviceAvailable: response.status < 500
+      };
+    }
+    const result = await response.json();
+    if (result.success) {
+      const outputInfo = typeof result.output === "object" && result.output !== null ? result.output : {};
+      logger.info("Compilation successful", {
+        compilerVersion: result.compilerVersion,
+        executionTime: result.executionTime,
+        circuits: outputInfo.circuits?.length || 0,
+        warnings: result.warnings?.length || 0
+      });
+      const version = result.compilerVersion || "unknown";
+      const execTime = result.executionTime ? ` in ${result.executionTime}ms` : "";
+      return {
+        success: true,
+        compilerVersion: version,
+        message: `\u2705 Compilation successful (Compiler v${version})${execTime}`,
+        circuits: outputInfo.circuits || [],
+        ledgerFields: outputInfo.ledgerFields || [],
+        exports: outputInfo.exports || [],
+        warnings: result.warnings || [],
+        serviceAvailable: true
+      };
+    } else {
+      const errors = result.errors || [];
+      const firstError = errors[0];
+      logger.info("Compilation failed", {
+        error: result.error,
+        errorCount: errors.length,
+        output: result.output,
+        firstError
+      });
+      let errorMessage = result.output || result.message || result.error || "Compilation failed";
+      if (firstError) {
+        errorMessage = `Line ${firstError.line}:${firstError.column} - ${firstError.message}`;
+      }
+      return {
+        success: false,
+        message: errorMessage,
+        error: result.error || "COMPILE_ERROR",
+        errors,
+        errorDetails: firstError ? {
+          line: firstError.line,
+          column: firstError.column,
+          errorType: firstError.severity
+        } : result.details,
+        serviceAvailable: true
+      };
+    }
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : "Unknown error";
+    if (error instanceof Error && error.name === "AbortError") {
+      logger.warn("Compiler request timed out");
+      return {
+        success: false,
+        message: "Compilation timed out - the contract may be too complex",
+        error: "TIMEOUT",
+        serviceAvailable: true
+      };
+    }
+    logger.error("Compiler service request failed", { error: errorMessage });
+    return {
+      success: false,
+      message: `Failed to connect to compiler service: ${errorMessage}`,
+      error: "CONNECTION_FAILED",
+      serviceAvailable: false
+    };
+  }
+}
+function getCompilerUrl() {
+  return COMPILER_API_URL;
+}
 
 // src/tools/analyze/handlers.ts
 async function analyzeContract(input) {
@@ -954,6 +1092,86 @@ function getPrivacyConsiderations(circuit) {
   }
   return considerations;
 }
+async function compileContract2(input) {
+  logger.info("Compiling Compact contract via hosted service", {
+    codeLength: input.code.length,
+    skipZk: input.skipZk,
+    fullCompile: input.fullCompile
+  });
+  const skipZk = input.fullCompile ? false : input.skipZk ?? true;
+  const result = await compileContract(input.code, {
+    wrapWithDefaults: true,
+    skipZk
+  });
+  if (result.success) {
+    return {
+      success: true,
+      message: result.message,
+      compilerVersion: result.compilerVersion,
+      compilationMode: skipZk ? "syntax-only" : "full",
+      validationType: "compiler",
+      output: {
+        circuits: result.circuits || [],
+        ledgerFields: result.ledgerFields || [],
+        exports: result.exports || []
+      },
+      warnings: result.warnings || [],
+      serviceUrl: getCompilerUrl()
+    };
+  } else {
+    if (!result.serviceAvailable) {
+      logger.warn(
+        "Compiler service unavailable, falling back to static analysis",
+        { error: result.error }
+      );
+      const staticResult = await analyzeContract({
+        code: input.code,
+        checkSecurity: true
+      });
+      const securityWarnings = (staticResult.securityFindings || []).map(
+        (f) => `[${f.severity}] ${f.message}`
+      );
+      return {
+        success: true,
+        // Static analysis succeeded
+        message: "Static analysis completed (compiler service unavailable)",
+        validationType: "static-analysis-fallback",
+        compilationMode: "none",
+        serviceAvailable: false,
+        serviceUrl: getCompilerUrl(),
+        fallbackReason: result.message,
+        warnings: securityWarnings,
+        staticAnalysis: {
+          summary: staticResult.summary,
+          structure: staticResult.structure,
+          securityFindings: staticResult.securityFindings,
+          recommendations: staticResult.recommendations
+        }
+      };
+    }
+    const errorInfo = {
+      success: false,
+      message: result.message,
+      error: result.error,
+      validationType: "compiler",
+      serviceAvailable: result.serviceAvailable,
+      serviceUrl: getCompilerUrl()
+    };
+    if (result.errorDetails) {
+      errorInfo.location = {
+        line: result.errorDetails.line,
+        column: result.errorDetails.column,
+        errorType: result.errorDetails.errorType
+      };
+    }
+    if (result.error === "TIMEOUT") {
+      errorInfo.hint = "The contract may be too complex. Try simplifying or breaking it into smaller pieces.";
+    } else if (result.errorDetails?.line) {
+      errorInfo.hint = `Check line ${result.errorDetails.line} for the issue.`;
+    }
+    return errorInfo;
+  }
+}
 
 // src/tools/analyze/tools.ts
 var analyzeContractOutputSchema = {
@@ -1098,6 +1316,99 @@ var explainCircuitOutputSchema = {
   ],
   description: "Detailed circuit explanation with privacy analysis"
 };
+var compileContractOutputSchema = {
+  type: "object",
+  properties: {
+    success: {
+      type: "boolean",
+      description: "Whether compilation/validation succeeded"
+    },
+    message: {
+      type: "string",
+      description: "Human-readable status message"
+    },
+    validationType: {
+      type: "string",
+      enum: ["compiler", "static-analysis-fallback"],
+      description: "Type of validation performed - compiler (real) or static-analysis-fallback (when service unavailable)"
+    },
+    compilerVersion: {
+      type: "string",
+      description: "Version of the Compact compiler used (if available)"
+    },
+    compilationMode: {
+      type: "string",
+      enum: ["syntax-only", "full", "none"],
+      description: "Type of compilation performed"
+    },
+    output: {
+      type: "object",
+      properties: {
+        circuits: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of compiled circuits"
+        },
+        ledgerFields: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of ledger fields"
+        },
+        exports: {
+          type: "array",
+          items: { type: "string" },
+          description: "List of exported symbols"
+        }
+      }
+    },
+    warnings: {
+      type: "array",
+      items: { type: "string" },
+      description: "Compiler warnings or fallback warnings"
+    },
+    error: {
+      type: "string",
+      description: "Error code if compilation failed"
+    },
+    location: {
+      type: "object",
+      properties: {
+        line: { type: "number" },
+        column: { type: "number" },
+        errorType: { type: "string" }
+      },
+      description: "Location of error if applicable"
+    },
+    hint: {
+      type: "string",
+      description: "Helpful hint for resolving the issue"
+    },
+    serviceUrl: {
+      type: "string",
+      description: "URL of the compiler service used"
+    },
+    serviceAvailable: {
+      type: "boolean",
+      description: "Whether the compiler service is available"
+    },
+    fallbackReason: {
+      type: "string",
+      description: "Reason for falling back to static analysis (if applicable)"
+    },
+    staticAnalysis: {
+      type: "object",
+      description: "Static analysis results (only present when using fallback)",
+      properties: {
+        summary: { type: "object" },
+        structure: { type: "object" },
+        securityFindings: { type: "array" },
+        recommendations: { type: "array" }
+      }
+    }
+  },
+  required: ["success", "message", "validationType"],
+  description: "Compilation result with detailed output, or static analysis fallback if service unavailable"
+};
 var analyzeTools = [
   {
     name: "midnight-analyze-contract",
@@ -1161,6 +1472,59 @@ USAGE GUIDANCE:
       category: "analyze"
     },
     handler: explainCircuit
+  },
+  {
+    name: "midnight-compile-contract",
+    description: `\u{1F527} REAL COMPILATION - Compile Compact code using the hosted compiler service.
+
+Unlike static analysis tools, this ACTUALLY COMPILES the contract and returns real compiler errors.
+
+Use this to:
+\u2022 Validate that generated code compiles before showing to users
+\u2022 Get actual compiler error messages with line numbers
+\u2022 Check if a contract is syntactically and semantically correct
+
+Options:
+\u2022 skipZk=true (default): Fast syntax validation only (~1-2s)
+\u2022 fullCompile=true: Full compilation with ZK circuit generation (~10-30s)
+
+FALLBACK BEHAVIOR:
+\u2022 If the compiler service is unavailable, automatically falls back to static analysis
+\u2022 Check 'validationType' in response: 'compiler' = real compilation, 'static-analysis-fallback' = fallback mode
+\u2022 Fallback provides structure/security analysis but may miss semantic errors
+
+USAGE GUIDANCE:
+\u2022 Call after generating or modifying Compact code
+\u2022 Use skipZk=true for quick validation during development
+\u2022 Use fullCompile=true for final validation before deployment`,
+    inputSchema: {
+      type: "object",
+      properties: {
+        code: {
+          type: "string",
+          description: "Compact contract source code to compile"
+        },
+        skipZk: {
+          type: "boolean",
+          description: "Skip ZK circuit generation for faster syntax-only validation (default: true)"
+        },
+        fullCompile: {
+          type: "boolean",
+          description: "Perform full compilation including ZK generation (slower but complete)"
+        }
+      },
+      required: ["code"]
+    },
+    outputSchema: compileContractOutputSchema,
+    annotations: {
+      readOnlyHint: true,
+      idempotentHint: true,
+      openWorldHint: true,
+      // Makes network requests
+      title: "\u{1F527} Compile Contract",
+      category: "analyze"
+    },
+    handler: compileContract2
   }
 ];
 
@@ -10821,4 +11185,4 @@ export {
   startServer,
   startHttpServer
 };
-//# sourceMappingURL=chunk-LXHUX67Z.js.map
+//# sourceMappingURL=chunk-V7KK64OX.js.map

package/dist/{chunk-FZI3KN52.js → chunk-WYQRVPIQ.js}

@@ -1593,7 +1593,7 @@ var releaseTracker = new ReleaseTracker();
 
 // src/utils/health.ts
 var startTime = Date.now();
-var VERSION = "0.2.13";
+var VERSION = "0.2.14";
 async function checkGitHubAPI() {
   const start = Date.now();
   try {
@@ -1621,7 +1621,7 @@ async function checkGitHubAPI() {
 }
 async function checkVectorStore() {
   try {
-    const { vectorStore: vectorStore2 } = await import("./db-33TMMHCY.js");
+    const { vectorStore: vectorStore2 } = await import("./db-UKVEAHIX.js");
     if (vectorStore2) {
       return {
         status: "pass",
@@ -2096,7 +2096,7 @@ function serialize(data) {
 }
 
 // src/utils/version.ts
-var CURRENT_VERSION = "0.2.13";
+var CURRENT_VERSION = "0.2.14";
 
 // src/db/vectorStore.ts
 var VectorStore = class {
@@ -2305,4 +2305,4 @@ export {
   serialize,
   CURRENT_VERSION
 };
-//# sourceMappingURL=chunk-FZI3KN52.js.map
+//# sourceMappingURL=chunk-WYQRVPIQ.js.map

package/dist/db-UKVEAHIX.js

@@ -0,0 +1,7 @@
+import {
+  vectorStore
+} from "./chunk-WYQRVPIQ.js";
+export {
+  vectorStore
+};
+//# sourceMappingURL=db-UKVEAHIX.js.map

package/dist/index.js

@@ -9,10 +9,10 @@ import {
   promptDefinitions,
   startHttpServer,
   startServer
-} from "./chunk-LXHUX67Z.js";
+} from "./chunk-V7KK64OX.js";
 import {
   logger
-} from "./chunk-FZI3KN52.js";
+} from "./chunk-WYQRVPIQ.js";
 export {
   allResources,
   allTools,

package/package.json

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

package/dist/db-33TMMHCY.js

@@ -1,7 +0,0 @@
-import {
-  vectorStore
-} from "./chunk-FZI3KN52.js";
-export {
-  vectorStore
-};
-//# sourceMappingURL=db-33TMMHCY.js.map