midnight-mcp 0.1.18 → 0.1.20

package/dist/tools/repository/tools.js

@@ -358,7 +358,7 @@ export const repositoryTools = [
     // ============================================================================
     {
         name: "midnight-validate-contract",
-        description: "🔍 VALIDATION TOOL: Compile and validate a Compact contract BEFORE deployment. This runs the actual Compact compiler to check for syntax errors, type errors, and other issues. Use this after writing or modifying contract code to catch errors early. Requires the Compact CLI to be installed locally. Accepts either source code directly OR a file path to a .compact file.",
+        description: "🔍 PRIMARY VERIFICATION: Compile and validate a Compact contract using the ACTUAL Compact compiler. **ALWAYS use this tool first** when verifying contract code - it catches real compilation errors that static analysis cannot detect. Returns detailed error messages with line numbers, suggested fixes, and actionable guidance. If the compiler is not installed, it will provide installation instructions. Accepts either source code directly OR a file path to a .compact file. For contracts you generate, ALWAYS validate with this tool before presenting to the user.",
         inputSchema: {
             type: "object",
             properties: {
@@ -454,7 +454,7 @@ export const repositoryTools = [
     },
     {
         name: "midnight-extract-contract-structure",
-        description: "📋 ANALYSIS TOOL: Extract the structure of a Compact contract - circuits, witnesses, ledger items, types, structs, and enums. Use this to understand what a contract does without reading all the code. Returns exported and internal definitions with line numbers. Accepts either source code directly OR a file path.",
+        description: "📋 STATIC ANALYSIS (not verification): Extract the structure of a Compact contract and detect common issues. Returns circuits, witnesses, ledger items, types, structs, enums, and **potentialIssues** (module-level const, stdlib collisions, sealed+export conflicts). **WARNING: This does NOT verify compilation** - use 'midnight-validate-contract' for actual compiler verification. Use this tool for: (1) understanding contract structure, (2) quick pre-checks before compilation, (3) fallback analysis when compiler unavailable. Do NOT claim a contract 'compiles correctly' based only on this tool.",
         inputSchema: {
             type: "object",
             properties: {
@@ -529,6 +529,26 @@ export const repositoryTools = [
                     type: "object",
                     description: "Counts of each type of definition",
                 },
+                potentialIssues: {
+                    type: "array",
+                    description: "Common issues detected by static analysis (NOT exhaustive - use validate_contract for real verification)",
+                    items: {
+                        type: "object",
+                        properties: {
+                            type: {
+                                type: "string",
+                                description: "Issue type: module_level_const, stdlib_name_collision, sealed_export_conflict, missing_constructor, stdlib_type_mismatch",
+                            },
+                            line: { type: "number" },
+                            message: { type: "string" },
+                            suggestion: { type: "string" },
+                            severity: {
+                                type: "string",
+                                enum: ["error", "warning"],
+                            },
+                        },
+                    },
+                },
                 summary: { type: "string" },
                 message: { type: "string" },
             },

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

@@ -549,6 +549,7 @@ export declare function extractContractStructure(input: ExtractContractStructure
     structure?: undefined;
     exports?: undefined;
     stats?: undefined;
+    potentialIssues?: undefined;
     summary?: undefined;
 } | {
     success: boolean;
@@ -561,6 +562,7 @@ export declare function extractContractStructure(input: ExtractContractStructure
     structure?: undefined;
     exports?: undefined;
     stats?: undefined;
+    potentialIssues?: undefined;
     summary?: undefined;
 } | {
     success: boolean;
@@ -620,6 +622,13 @@ export declare function extractContractStructure(input: ExtractContractStructure
         exportedWitnesses: number;
         exportedLedger: number;
     };
+    potentialIssues: {
+        type: string;
+        line?: number;
+        message: string;
+        suggestion: string;
+        severity: "error" | "warning";
+    }[] | undefined;
     summary: string;
     message: string;
     error?: undefined;

package/dist/tools/repository/validation.js

@@ -1156,6 +1156,144 @@ export async function extractContractStructure(input) {
         witnesses: witnesses.filter((w) => w.isExport).map((w) => w.name),
         ledger: ledgerItems.filter((l) => l.isExport).map((l) => l.name),
     };
+    // ============================================================================
+    // PRE-COMPILATION ISSUE DETECTION
+    // Catch common mistakes before hitting the compiler
+    // ============================================================================
+    const potentialIssues = [];
+    // Known CompactStandardLibrary exports that shouldn't be redefined
+    const stdlibExports = [
+        "burnAddress",
+        "ownPublicKey",
+        "contractAddress",
+        "default",
+        "disclose",
+        "assert",
+        "pad",
+        "unpad",
+        "Counter",
+        "Map",
+        "Set",
+        "MerkleTree",
+        "Opaque",
+        "Vector",
+    ];
+    // 1. Detect module-level const (not supported in Compact)
+    const constPattern = /^const\s+(\w+)\s*:/gm;
+    let constMatch;
+    while ((constMatch = constPattern.exec(code)) !== null) {
+        // Check if this const is inside a circuit block by looking for preceding circuit/constructor
+        const beforeConst = code.substring(0, constMatch.index);
+        const lastCircuitStart = Math.max(beforeConst.lastIndexOf("circuit "), beforeConst.lastIndexOf("constructor {"));
+        const lastCloseBrace = beforeConst.lastIndexOf("}");
+        // If no circuit before, or the last } is after the last circuit start, it's module-level
+        if (lastCircuitStart === -1 || lastCloseBrace > lastCircuitStart) {
+            const lineNum = lineByIndex[constMatch.index] || 1;
+            potentialIssues.push({
+                type: "module_level_const",
+                line: lineNum,
+                message: `Module-level 'const ${constMatch[1]}' is not supported in Compact`,
+                suggestion: `Use 'pure circuit ${constMatch[1]}(): <type> { return <value>; }' instead`,
+                severity: "error",
+            });
+        }
+    }
+    // 2. Detect standard library name collisions
+    const hasStdlibImport = imports.includes("CompactStandardLibrary") ||
+        code.includes('include "std"');
+    if (hasStdlibImport) {
+        // Check circuits for name collisions
+        for (const circuit of circuits) {
+            if (stdlibExports.includes(circuit.name)) {
+                potentialIssues.push({
+                    type: "stdlib_name_collision",
+                    line: circuit.line,
+                    message: `Circuit '${circuit.name}' conflicts with CompactStandardLibrary.${circuit.name}()`,
+                    suggestion: `Rename to avoid ambiguity, or remove to use the standard library version`,
+                    severity: "error",
+                });
+            }
+        }
+    }
+    // 3. Detect sealed + export conflicts
+    const sealedFields = [];
+    const sealedPattern = /sealed\s+ledger\s+(\w+)\s*:/g;
+    let sealedMatch;
+    while ((sealedMatch = sealedPattern.exec(code)) !== null) {
+        const lineNum = lineByIndex[sealedMatch.index] || 1;
+        sealedFields.push({ name: sealedMatch[1], line: lineNum });
+    }
+    if (sealedFields.length > 0) {
+        // Check if any exported circuit writes to sealed fields
+        for (const circuit of circuits) {
+            if (circuit.isExport) {
+                // Find the circuit body and check for assignments to sealed fields
+                const circuitBodyMatch = code.match(new RegExp(`(?:export\\s+)?circuit\\s+${circuit.name}\\s*\\([^)]*\\)\\s*:[^{]*\\{([\\s\\S]*?)\\n\\}`, "m"));
+                if (circuitBodyMatch) {
+                    const body = circuitBodyMatch[1];
+                    for (const field of sealedFields) {
+                        // Check for assignment patterns: fieldName = or fieldName.method(
+                        if (new RegExp(`\\b${field.name}\\s*=`).test(body) ||
+                            new RegExp(`\\b${field.name}\\s*\\.\\s*\\w+\\s*\\(`).test(body)) {
+                            potentialIssues.push({
+                                type: "sealed_export_conflict",
+                                line: circuit.line,
+                                message: `Exported circuit '${circuit.name}' modifies sealed field '${field.name}'`,
+                                suggestion: `Move sealed field initialization to a 'constructor { }' block instead`,
+                                severity: "error",
+                            });
+                        }
+                    }
+                }
+            }
+        }
+    }
+    // 4. Detect missing constructor when sealed fields exist but no constructor
+    if (sealedFields.length > 0) {
+        const hasConstructor = /constructor\s*\{/.test(code);
+        if (!hasConstructor) {
+            // Check if there's an initialize-like circuit trying to set sealed fields
+            const initCircuit = circuits.find((c) => c.name.toLowerCase().includes("init") ||
+                c.name.toLowerCase() === "setup");
+            if (initCircuit && initCircuit.isExport) {
+                potentialIssues.push({
+                    type: "missing_constructor",
+                    line: initCircuit.line,
+                    message: `Contract has sealed fields but uses '${initCircuit.name}' instead of constructor`,
+                    suggestion: `Sealed fields must be initialized in 'constructor { }', not in exported circuits`,
+                    severity: "warning",
+                });
+            }
+        }
+    }
+    // 5. Detect potential type mismatches with stdlib functions
+    if (hasStdlibImport) {
+        // Check for burnAddress() used where ZswapCoinPublicKey is expected
+        // burnAddress() returns Either<ZswapCoinPublicKey, ContractAddress>
+        const burnAddressUsages = code.matchAll(/burnAddress\s*\(\s*\)/g);
+        for (const usage of burnAddressUsages) {
+            // Check if it's being passed to a function or assigned
+            const afterUsage = code.substring(usage.index + usage[0].length, usage.index + usage[0].length + 50);
+            const beforeUsage = code.substring(Math.max(0, usage.index - 100), usage.index);
+            // If used in a context expecting ZswapCoinPublicKey (not .left or .right access)
+            if (!afterUsage.startsWith(".left") &&
+                !afterUsage.startsWith(".right") &&
+                !afterUsage.startsWith(".is_left")) {
+                // Check if it's in a function call or assignment that likely expects ZswapCoinPublicKey
+                if (/\(\s*$/.test(beforeUsage) || /,\s*$/.test(beforeUsage)) {
+                    const lineNum = lineByIndex[usage.index] || 1;
+                    potentialIssues.push({
+                        type: "stdlib_type_mismatch",
+                        line: lineNum,
+                        message: `burnAddress() returns Either<ZswapCoinPublicKey, ContractAddress>, not ZswapCoinPublicKey`,
+                        suggestion: `Use burnAddress().left for ZswapCoinPublicKey, or define 'pure circuit zeroKey(): ZswapCoinPublicKey { return default<ZswapCoinPublicKey>; }'`,
+                        severity: "warning",
+                    });
+                    break; // Only warn once
+                }
+            }
+        }
+    }
     const summary = [];
     if (circuits.length > 0) {
         summary.push(`${circuits.length} circuit(s)`);
@@ -1201,8 +1339,11 @@ export async function extractContractStructure(input) {
             exportedWitnesses: exports.witnesses.length,
             exportedLedger: exports.ledger.length,
         },
+        potentialIssues: potentialIssues.length > 0 ? potentialIssues : undefined,
         summary: summary.length > 0 ? summary.join(", ") : "Empty contract",
-        message: `📋 Contract contains: ${summary.join(", ") || "no definitions found"}`,
+        message: potentialIssues.length > 0
+            ? `⚠️ Found ${potentialIssues.length} potential issue(s). Contract contains: ${summary.join(", ") || "no definitions found"}`
+            : `📋 Contract contains: ${summary.join(", ") || "no definitions found"}`,
     };
 }
 //# sourceMappingURL=validation.js.map

package/package.json

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