midnight-mcp 0.1.41 → 0.2.1

package/package.json

@@ -1,20 +1,23 @@
 {
   "name": "midnight-mcp",
-  "version": "0.1.41",
+  "version": "0.2.1",
   "description": "Model Context Protocol Server for Midnight Blockchain Development",
   "type": "module",
   "main": "dist/index.js",
   "bin": {
-    "midnight-mcp": "./dist/index.js"
+    "midnight-mcp": "./dist/bin.js"
   },
   "scripts": {
-    "build": "tsc",
-    "start": "node dist/index.js",
-    "dev": "tsx watch src/index.ts",
+    "build": "tsup",
+    "typecheck": "tsc --noEmit",
+    "start": "node dist/bin.js --stdio",
+    "start:http": "node dist/bin.js --http",
+    "dev": "NODE_ENV=development tsup --watch",
     "test": "vitest",
     "test:coverage": "vitest --coverage",
     "format": "prettier --write src/**/*.ts",
-    "prepublishOnly": "npm run build"
+    "prepublishOnly": "npm run typecheck && npm run build",
+    "ci": "npm run typecheck && npm run build && npm test"
   },
   "keywords": [
     "midnight",
@@ -32,15 +35,22 @@
     "@modelcontextprotocol/sdk": "^1.0.0",
     "chromadb": "^1.8.1",
     "dotenv": "^16.3.1",
+    "express": "^5.2.1",
+    "js-yaml": "^4.1.1",
     "octokit": "^3.1.2",
     "openai": "^4.20.1",
+    "yargs": "^18.0.0",
     "zod": "^3.22.4"
   },
   "devDependencies": {
+    "@types/express": "^5.0.6",
+    "@types/js-yaml": "^4.0.9",
     "@types/node": "^20.10.0",
     "@types/tar": "^6.1.13",
+    "@types/yargs": "^17.0.35",
     "prettier": "^3.1.0",
     "tar": "^7.5.2",
+    "tsup": "^8.5.1",
     "tsx": "^4.6.2",
     "typescript": "^5.3.2",
     "vitest": "^1.0.0"

package/dist/config/compact-version.d.ts

@@ -1,183 +0,0 @@
-/**
- * Compact Language Version Configuration
- *
- * MAINTAINER: Update these values when Compact language syntax changes!
- * See docs/SYNTAX_MAINTENANCE.md for the full update checklist.
- */
-/**
- * Supported Compact language version range
- * Update when new compiler versions are released
- */
-export declare const COMPACT_VERSION: {
-    /** Minimum supported version */
-    min: string;
-    /** Maximum supported version */
-    max: string;
-    /** When this config was last updated */
-    lastUpdated: string;
-    /** Source of truth for syntax patterns */
-    referenceSource: string;
-};
-/**
- * Current pragma format that should be used in contracts
- */
-export declare const RECOMMENDED_PRAGMA: string;
-/**
- * Known deprecated patterns (add new ones here when Compact evolves)
- */
-export declare const DEPRECATED_PATTERNS: {
-    /** Deprecated in: 0.16 */
-    ledgerBlock: {
-        pattern: RegExp;
-        since: string;
-        replacement: string;
-        description: string;
-    };
-    /** Deprecated in: 0.15 */
-    cellWrapper: {
-        pattern: RegExp;
-        since: string;
-        replacement: string;
-        description: string;
-    };
-    /** Never existed */
-    voidType: {
-        pattern: RegExp;
-        since: string;
-        replacement: string;
-        description: string;
-    };
-};
-/**
- * Reference contracts known to compile successfully
- * Use these to verify syntax is still correct
- */
-export declare const REFERENCE_CONTRACTS: {
-    name: string;
-    repo: string;
-    description: string;
-}[];
-/**
- * Get the version info as a string for display
- */
-export declare function getVersionInfo(): string;
-/**
- * Check if a version is within supported range
- */
-export declare function isVersionSupported(version: string): boolean;
-/**
- * Built-in functions vs patterns you must implement yourself
- * CRITICAL: These are the actual stdlib functions available in Compact
- */
-export declare const BUILTIN_FUNCTIONS: {
-    /** Actually built into the language/stdlib */
-    stdlib: {
-        name: string;
-        signature: string;
-        description: string;
-    }[];
-    /** NOT built-in - you must implement these patterns yourself */
-    notBuiltIn: {
-        name: string;
-        wrongUsage: string;
-        correctPattern: string;
-        description: string;
-    }[];
-};
-/**
- * Type compatibility rules - what types can be compared/operated together
- */
-export declare const TYPE_COMPATIBILITY: {
-    comparisons: ({
-        types: string;
-        works: boolean;
-        note: string;
-        fix?: undefined;
-    } | {
-        types: string;
-        works: boolean;
-        fix: string;
-        note?: undefined;
-    })[];
-    arithmetic: ({
-        types: string;
-        works: boolean;
-        note: string;
-        fix?: undefined;
-    } | {
-        types: string;
-        works: boolean;
-        fix: string;
-        note?: undefined;
-    })[];
-    typeCasting: ({
-        from: string;
-        to: string;
-        direct: boolean;
-        fix: string;
-        note?: undefined;
-    } | {
-        from: string;
-        to: string;
-        direct: boolean;
-        note: string;
-        fix?: undefined;
-    })[];
-    assignments: {
-        types: string;
-        works: boolean;
-        fix: string;
-    }[];
-    tips: string[];
-};
-/**
- * Ledger type limitations - what works in circuits vs TypeScript
- */
-export declare const LEDGER_TYPE_LIMITS: {
-    Counter: {
-        circuitOperations: {
-            method: string;
-            works: boolean;
-            note: string;
-        }[];
-        typescriptAccess: string;
-        reason: string;
-    };
-    Map: {
-        circuitOperations: {
-            method: string;
-            works: boolean;
-            note: string;
-        }[];
-        typescriptAccess: string;
-        note: string;
-    };
-    Set: {
-        circuitOperations: {
-            method: string;
-            works: boolean;
-            note: string;
-        }[];
-        typescriptAccess: string;
-        note: string;
-    };
-    MerkleTree: {
-        circuitOperations: {
-            method: string;
-            works: boolean;
-            note: string;
-        }[];
-        typescriptAccess: string;
-        pattern: string;
-    };
-};
-/**
- * Common compilation errors with their fixes
- * Maps actual compiler error messages to solutions
- */
-export declare const COMMON_ERRORS: {
-    error: string;
-    cause: string;
-    fix: string;
-}[];
-//# sourceMappingURL=compact-version.d.ts.map

package/dist/config/compact-version.js

@@ -1,423 +0,0 @@
-/**
- * Compact Language Version Configuration
- *
- * MAINTAINER: Update these values when Compact language syntax changes!
- * See docs/SYNTAX_MAINTENANCE.md for the full update checklist.
- */
-/**
- * Supported Compact language version range
- * Update when new compiler versions are released
- */
-export const COMPACT_VERSION = {
-    /** Minimum supported version */
-    min: "0.16",
-    /** Maximum supported version */
-    max: "0.18",
-    /** When this config was last updated */
-    lastUpdated: "2025-01-26",
-    /** Source of truth for syntax patterns */
-    referenceSource: "https://github.com/piotr-iohk/template-contract",
-};
-/**
- * Current pragma format that should be used in contracts
- */
-export const RECOMMENDED_PRAGMA = `pragma language_version >= ${COMPACT_VERSION.min} && <= ${COMPACT_VERSION.max};`;
-/**
- * Known deprecated patterns (add new ones here when Compact evolves)
- */
-export const DEPRECATED_PATTERNS = {
-    /** Deprecated in: 0.16 */
-    ledgerBlock: {
-        pattern: /ledger\s*\{/,
-        since: "0.16",
-        replacement: "export ledger fieldName: Type;",
-        description: "Block-style ledger declarations",
-    },
-    /** Deprecated in: 0.15 */
-    cellWrapper: {
-        pattern: /Cell\s*<\s*\w+\s*>/,
-        since: "0.15",
-        replacement: "Type (without Cell wrapper)",
-        description: "Cell<T> type wrapper",
-    },
-    /** Never existed */
-    voidType: {
-        pattern: /:\s*Void\b/,
-        since: "always",
-        replacement: "[] (empty tuple)",
-        description: "Void return type",
-    },
-};
-/**
- * Reference contracts known to compile successfully
- * Use these to verify syntax is still correct
- */
-export const REFERENCE_CONTRACTS = [
-    {
-        name: "template-contract",
-        repo: "piotr-iohk/template-contract",
-        description: "Official Midnight template contract",
-    },
-    {
-        name: "tokenomics-project",
-        repo: "piotr-iohk/tokenomics-project",
-        description: "Token implementation example",
-    },
-    {
-        name: "zswap-example",
-        repo: "piotr-iohk/zswap-example",
-        description: "Privacy-preserving swap example",
-    },
-    {
-        name: "reentrancy-example",
-        repo: "piotr-iohk/reentrancy-example",
-        description: "Cross-contract call patterns",
-    },
-];
-/**
- * Get the version info as a string for display
- */
-export function getVersionInfo() {
-    return `Compact ${COMPACT_VERSION.min}-${COMPACT_VERSION.max} (updated ${COMPACT_VERSION.lastUpdated})`;
-}
-/**
- * Check if a version is within supported range
- */
-export function isVersionSupported(version) {
-    const [major, minor] = version.split(".").map(Number);
-    const [minMajor, minMinor] = COMPACT_VERSION.min.split(".").map(Number);
-    const [maxMajor, maxMinor] = COMPACT_VERSION.max.split(".").map(Number);
-    const versionNum = major * 100 + minor;
-    const minNum = minMajor * 100 + minMinor;
-    const maxNum = maxMajor * 100 + maxMinor;
-    return versionNum >= minNum && versionNum <= maxNum;
-}
-/**
- * Built-in functions vs patterns you must implement yourself
- * CRITICAL: These are the actual stdlib functions available in Compact
- */
-export const BUILTIN_FUNCTIONS = {
-    /** Actually built into the language/stdlib */
-    stdlib: [
-        {
-            name: "persistentHash",
-            signature: "persistentHash<T>(value: T): Bytes<32>",
-            description: "Poseidon hash that produces consistent results across calls",
-        },
-        {
-            name: "persistentCommit",
-            signature: "persistentCommit<T>(value: T): Bytes<32>",
-            description: "Creates a hiding commitment to a value",
-        },
-        {
-            name: "pad",
-            signature: "pad(length: number, value: string): Bytes<N>",
-            description: "Pads a string to fixed-length bytes",
-        },
-        {
-            name: "disclose",
-            signature: "disclose(value: T): T",
-            description: "Explicitly reveals a witness value (required in conditionals)",
-        },
-        {
-            name: "assert",
-            signature: "assert(condition: Boolean, message?: string): []",
-            description: "Fails circuit if condition is false",
-        },
-        {
-            name: "default",
-            signature: "default<T>(): T",
-            description: "Returns default value for a type (0 for numbers, empty for collections)",
-        },
-    ],
-    /** NOT built-in - you must implement these patterns yourself */
-    notBuiltIn: [
-        {
-            name: "public_key",
-            wrongUsage: "public_key(sk) // ERROR: unbound identifier",
-            correctPattern: `// Derive public key using persistentHash
-const pk = persistentHash<Vector<2, Bytes<32>>>([
-  pad(32, "midnight:pk:"),
-  sk
-]);`,
-            description: "Public key derivation is NOT a builtin - use persistentHash pattern",
-        },
-        {
-            name: "verify_signature",
-            wrongUsage: "verify_signature(msg, sig, pk) // Does not exist",
-            correctPattern: `// Signature verification must be done via witnesses
-// The prover verifies off-chain, then provides the boolean result
-witness signature_valid(): Boolean;`,
-            description: "Signature verification is done off-chain in the prover",
-        },
-        {
-            name: "random",
-            wrongUsage: "random() // Does not exist in ZK circuits",
-            correctPattern: `// Randomness must come from witnesses (prover-provided)
-witness get_random_value(): Field;`,
-            description: "ZK circuits are deterministic - randomness must come from witnesses",
-        },
-    ],
-};
-/**
- * Type compatibility rules - what types can be compared/operated together
- */
-export const TYPE_COMPATIBILITY = {
-    comparisons: [
-        { types: "Field == Field", works: true, note: "Direct comparison" },
-        {
-            types: "Field == Uint<N>",
-            works: false,
-            fix: "Cast with `value as Field`",
-        },
-        {
-            types: "Field >= 0",
-            works: false,
-            fix: "Use bounded Uint<0..N> parameter instead",
-        },
-        { types: "Uint<N> == Uint<N>", works: true, note: "Same-width comparison" },
-        {
-            types: "Uint<0..2> == Uint<0..2>",
-            works: true,
-            note: "Bounded integers",
-        },
-        { types: "Bytes<32> == Bytes<32>", works: true, note: "Direct comparison" },
-        { types: "Boolean == Boolean", works: true, note: "Direct comparison" },
-    ],
-    arithmetic: [
-        { types: "Field + Field", works: true, note: "Field arithmetic" },
-        { types: "Field + Uint<N>", works: false, fix: "Cast Uint to Field first" },
-        {
-            types: "Uint<N> + Uint<N>",
-            works: true,
-            note: "Result is bounded type, cast back: (a + b) as Uint<64>",
-        },
-        {
-            types: "Uint<64> + Uint<64>",
-            works: true,
-            note: "Result is Uint<0..36893488147419103230>, must cast: (a + b) as Uint<64>",
-        },
-        {
-            types: "Uint<64> * Uint<64>",
-            works: true,
-            note: "Result is wide bounded type, cast back to target type",
-        },
-    ],
-    typeCasting: [
-        {
-            from: "Uint<64>",
-            to: "Bytes<32>",
-            direct: false,
-            fix: "Go through Field: (amount as Field) as Bytes<32>",
-        },
-        {
-            from: "Uint<N>",
-            to: "Field",
-            direct: true,
-            note: "Safe cast: value as Field",
-        },
-        {
-            from: "arithmetic result",
-            to: "Uint<64>",
-            direct: true,
-            note: "Required cast: (a + b) as Uint<64>",
-        },
-    ],
-    assignments: [
-        {
-            types: "Field = Uint<N>",
-            works: false,
-            fix: "Cast with `value as Field`",
-        },
-        {
-            types: "Uint<N> = Field",
-            works: false,
-            fix: "Use bounded param or explicit cast",
-        },
-    ],
-    tips: [
-        "Use Uint<0..N> for circuit parameters that need range validation",
-        "Field is unbounded - use for hashes, commitments, general computation",
-        "Uint<N> is bounded - use when you need range checks",
-        "Casting with `as Field` is safe but loses range information",
-    ],
-};
-/**
- * Ledger type limitations - what works in circuits vs TypeScript
- */
-export const LEDGER_TYPE_LIMITS = {
-    Counter: {
-        circuitOperations: [
-            { method: ".increment(n)", works: true, note: "Adds n to counter" },
-            {
-                method: ".decrement(n)",
-                works: true,
-                note: "Subtracts n from counter",
-            },
-            { method: ".resetToDefault()", works: true, note: "Resets to 0" },
-            { method: ".value()", works: false, note: "NOT available in circuits" },
-        ],
-        typescriptAccess: "Access counter value via `ledgerState.counter` in TypeScript SDK",
-        reason: "ZK circuits cannot read current ledger state - only modify it",
-    },
-    Map: {
-        circuitOperations: [
-            {
-                method: ".insert(key, value)",
-                works: true,
-                note: "Adds/updates entry",
-            },
-            { method: ".remove(key)", works: true, note: "Removes entry" },
-            {
-                method: ".lookup(key)",
-                works: true,
-                note: "Returns Option<ValueType> - use in circuits",
-            },
-            {
-                method: ".member(key)",
-                works: true,
-                note: "Returns Boolean - checks if key exists",
-            },
-        ],
-        typescriptAccess: "Query map via `contractState.data.get(key)` in TypeScript SDK",
-        note: "Map.lookup() and Map.member() ARE available in circuits (verified with OpenZeppelin contracts)",
-    },
-    Set: {
-        circuitOperations: [
-            { method: ".insert(value)", works: true, note: "Adds to set" },
-            { method: ".remove(value)", works: true, note: "Removes from set" },
-            {
-                method: ".member(value)",
-                works: true,
-                note: "Returns Boolean - checks if value exists in set",
-            },
-        ],
-        typescriptAccess: "Check membership via `contractState.set.has(value)` in TypeScript SDK",
-        note: "Set.member() IS available in circuits",
-    },
-    MerkleTree: {
-        circuitOperations: [
-            { method: ".insert(leaf)", works: true, note: "Adds leaf to tree" },
-            { method: ".root()", works: false, note: "NOT available in circuits" },
-        ],
-        typescriptAccess: "Get root via `contractState.tree.root` in TypeScript SDK",
-        pattern: `// To verify a merkle proof in circuit:
-witness get_merkle_root(): Bytes<32>;
-witness get_merkle_proof(leaf: Bytes<32>): Vector<32, Bytes<32>>;
-
-// Verify proof using persistentHash to compute expected root`,
-    },
-};
-/**
- * Common compilation errors with their fixes
- * Maps actual compiler error messages to solutions
- */
-export const COMMON_ERRORS = [
-    {
-        error: 'unbound identifier "public_key"',
-        cause: "Trying to use public_key() as if it's a builtin function",
-        fix: `Use persistentHash pattern instead:
-const pk = persistentHash<Vector<2, Bytes<32>>>([pad(32, "midnight:pk:"), sk]);`,
-    },
-    {
-        error: "incompatible combination of types Field and Uint",
-        cause: "Comparing or operating on Field with Uint without casting",
-        fix: `Cast Uint to Field: (myUint as Field)
-Or use bounded Uint<0..N> for parameters that need constraints`,
-    },
-    {
-        error: 'operation "value" undefined for ledger field type Counter',
-        cause: "Trying to read Counter.value() inside a circuit",
-        fix: `Counter values cannot be read in circuits. Options:
-1. Use a witness: witness get_counter_value(): Uint<64>;
-2. Read from TypeScript SDK: ledgerState.counter
-3. Track the value in a separate Field ledger variable`,
-    },
-    {
-        error: "implicit disclosure of witness value",
-        cause: "Using witness value in conditional without disclose()",
-        fix: `Wrap witness comparisons in disclose():
-if (disclose(witness_value == expected)) { ... }`,
-    },
-    {
-        error: 'parse error: found "{" looking for an identifier',
-        cause: "Using old ledger { } block syntax",
-        fix: `Use individual exports instead:
-export ledger field1: Type1;
-export ledger field2: Type2;`,
-    },
-    {
-        error: 'parse error: found "{" looking for ";"',
-        cause: "Using Void as return type (doesn't exist)",
-        fix: `Use empty tuple [] for no return value:
-export circuit myCircuit(): [] { ... }`,
-    },
-    {
-        error: 'unbound identifier "Cell"',
-        cause: "Using deprecated Cell<T> wrapper (removed in 0.15)",
-        fix: `Remove Cell wrapper, just use the type directly:
-export ledger myField: Field;  // Not Cell<Field>`,
-    },
-    {
-        error: "member access requires struct type",
-        cause: "Trying to access a field on a non-struct type",
-        fix: `Make sure you're accessing a struct field, not a primitive.
-Map.lookup() and Map.member() ARE available in circuits.
-Check that the base type is actually a struct.`,
-    },
-    {
-        error: "potential witness-value disclosure must be declared",
-        cause: "Circuit parameter flows to ledger operation without disclose()",
-        fix: `Disclose parameters at the start of the circuit:
-export circuit my_circuit(param: Bytes<32>): [] {
-  const d_param = disclose(param);  // Acknowledge on-chain visibility
-  ledger.insert(d_param, value);    // Now use disclosed value
-}`,
-    },
-    {
-        error: "expected second argument of insert to have type Uint<64> but received Uint<0..N>",
-        cause: "Arithmetic result has bounded type, needs cast back to target",
-        fix: `Cast arithmetic results back to the target type:
-const new_balance = (current + amount) as Uint<64>;
-ledger_map.insert(key, new_balance);`,
-    },
-    {
-        error: "cannot cast from type Uint<64> to type Bytes<32>",
-        cause: "Direct Uint to Bytes cast not allowed",
-        fix: `Go through Field first:
-const amount_field = amount as Field;
-const amount_bytes = amount_field as Bytes<32>;
-// Or chained: (amount as Field) as Bytes<32>`,
-    },
-    {
-        error: "cannot prove assertion",
-        cause: "Assert condition cannot be proven true",
-        fix: `Check your logic. Common causes:
-1. Witness returns unexpected value
-2. Range check fails (use bounded Uint)
-3. Logic error in circuit`,
-    },
-    {
-        error: 'parse error: found ":" looking for ")"',
-        cause: "Using Rust-style :: for enum variant access",
-        fix: `Use dot notation for enum variants:
-WRONG:  Choice::rock, GameState::waiting
-CORRECT: Choice.rock, GameState.waiting`,
-    },
-    {
-        error: 'parse error: found "{" after witness declaration',
-        cause: "Trying to add implementation body to witness",
-        fix: `Witnesses are declarations only - no body allowed:
-WRONG:  witness get_caller(): Bytes<32> { return ...; }
-CORRECT: witness get_caller(): Bytes<32>;
-Implementation goes in TypeScript prover, not Compact.`,
-    },
-    {
-        error: 'unbound identifier "function"',
-        cause: 'Using "pure function" instead of "pure circuit"',
-        fix: `Use "pure circuit" for helper functions:
-WRONG:  pure function helper(...): Type { }
-CORRECT: pure circuit helper(...): Type { }`,
-    },
-];
-//# sourceMappingURL=compact-version.js.map

package/dist/db/index.d.ts

@@ -1,3 +0,0 @@
-export { vectorStore } from "./vectorStore.js";
-export type { CodeDocument, SearchResult, SearchFilter } from "./vectorStore.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/db/index.js

@@ -1,2 +0,0 @@
-export { vectorStore } from "./vectorStore.js";
-//# sourceMappingURL=index.js.map