midnight-mcp 0.1.19 → 0.1.21

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.js

@@ -1294,6 +1294,91 @@ export async function extractContractStructure(input) {
             }
         }
     }
+    // 6. Detect division operator usage (not supported in Compact)
+    const divisionPattern = /[^/]\/[^/*]/g;
+    let divMatch;
+    while ((divMatch = divisionPattern.exec(code)) !== null) {
+        // Skip if inside a comment
+        const beforeDiv = code.substring(0, divMatch.index);
+        const lastLineStart = beforeDiv.lastIndexOf("\n") + 1;
+        const lineContent = beforeDiv.substring(lastLineStart);
+        if (lineContent.includes("//"))
+            continue;
+        const lineNum = lineByIndex[divMatch.index] || 1;
+        potentialIssues.push({
+            type: "unsupported_division",
+            line: lineNum,
+            message: `Division operator '/' is not supported in Compact`,
+            suggestion: `Use a witness-based division pattern: 'witness divideWithRemainder(a, b): [quotient, remainder]' with on-chain verification`,
+            severity: "error",
+        });
+        break; // Only warn once
+    }
+    // 7. Detect Counter.value access (Counter only has .increment())
+    const counterValuePattern = /(\w+)\.value\b/g;
+    let counterMatch;
+    while ((counterMatch = counterValuePattern.exec(code)) !== null) {
+        const varName = counterMatch[1];
+        // Check if this variable is a Counter type
+        const counterLedger = ledgerItems.find((l) => l.name === varName && l.type === "Counter");
+        if (counterLedger) {
+            const lineNum = lineByIndex[counterMatch.index] || 1;
+            potentialIssues.push({
+                type: "invalid_counter_access",
+                line: lineNum,
+                message: `Counter type '${varName}' does not have a '.value' property`,
+                suggestion: `Counter only has '.increment(n)'. Use 'Uint<32>' or 'Uint<64>' instead if you need to read the value`,
+                severity: "error",
+            });
+        }
+    }
+    // 8. Detect potential Uint overflow in multiplication (suggest Field casting)
+    const multiplyPattern = /(\w+)\s*\*\s*(\w+)(?:\s*\+\s*\w+)?\s*(?:as\s+Uint|==)/g;
+    let multMatch;
+    while ((multMatch = multiplyPattern.exec(code)) !== null) {
+        // Check if operands are likely Uint types and not already cast to Field
+        const beforeMult = code.substring(Math.max(0, multMatch.index - 200), multMatch.index);
+        const afterMult = code.substring(multMatch.index, multMatch.index + multMatch[0].length + 50);
+        // Skip if already casting to Field
+        if (afterMult.includes("as Field") || beforeMult.includes("as Field"))
+            continue;
+        // Check if this looks like a verification pattern (common in witness verification)
+        if (/assert|==/.test(afterMult)) {
+            const lineNum = lineByIndex[multMatch.index] || 1;
+            potentialIssues.push({
+                type: "potential_overflow",
+                line: lineNum,
+                message: `Multiplication '${multMatch[1]} * ${multMatch[2]}' may overflow Uint bounds`,
+                suggestion: `Cast operands to Field for safe arithmetic: '(${multMatch[1]} as Field) * (${multMatch[2]} as Field)'`,
+                severity: "warning",
+            });
+            break; // Only warn once
+        }
+    }
+    // 9. Detect witness/private values used in conditionals without disclose()
+    // Look for patterns like: if (witnessVar ...) or if (param == privateValue)
+    const witnessNames = witnesses.map((w) => w.name);
+    const ifPattern = /if\s*\(([^)]+)\)/g;
+    let ifMatch;
+    while ((ifMatch = ifPattern.exec(code)) !== null) {
+        const condition = ifMatch[1];
+        // Check if condition uses a witness value without disclose
+        for (const witnessName of witnessNames) {
+            if (condition.includes(witnessName) &&
+                !condition.includes(`disclose(${witnessName}`) &&
+                !condition.includes("disclose(")) {
+                const lineNum = lineByIndex[ifMatch.index] || 1;
+                potentialIssues.push({
+                    type: "undisclosed_witness_conditional",
+                    line: lineNum,
+                    message: `Witness value '${witnessName}' used in conditional without disclose()`,
+                    suggestion: `Wrap witness comparisons in disclose(): 'if (disclose(${witnessName} == expected))'`,
+                    severity: "warning",
+                });
+                break;
+            }
+        }
+    }
     const summary = [];
     if (circuits.length > 0) {
         summary.push(`${circuits.length} circuit(s)`);

package/package.json

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