midnight-mcp 0.1.41 → 0.2.2

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

package/dist/db/vectorStore.d.ts

@@ -1,69 +0,0 @@
-export interface CodeDocument {
-    id: string;
-    content: string;
-    embedding?: number[];
-    metadata: {
-        repository: string;
-        filePath: string;
-        language: string;
-        startLine: number;
-        endLine: number;
-        codeType: string;
-        codeName: string;
-        isPublic: boolean;
-        repoVersion?: string;
-        pragmaVersion?: string;
-        indexedAt?: string;
-    };
-}
-export interface SearchResult {
-    id: string;
-    content: string;
-    score: number;
-    metadata: CodeDocument["metadata"];
-}
-export interface SearchFilter {
-    repository?: string;
-    language?: string;
-    codeType?: string;
-    isPublic?: boolean;
-}
-declare class VectorStore {
-    private client;
-    private collection;
-    private collectionName;
-    private initialized;
-    /**
-     * Initialize the vector store connection
-     */
-    initialize(): Promise<void>;
-    /**
-     * Add documents to the vector store
-     */
-    addDocuments(documents: CodeDocument[]): Promise<void>;
-    /**
-     * Search for similar documents
-     */
-    search(query: string, limit?: number, filter?: SearchFilter): Promise<SearchResult[]>;
-    /**
-     * Delete documents by file path
-     */
-    deleteByPath(repository: string, filePath: string): Promise<void>;
-    /**
-     * Delete all documents for a repository
-     */
-    deleteRepository(repository: string): Promise<void>;
-    /**
-     * Get collection statistics
-     */
-    getStats(): Promise<{
-        count: number;
-    }>;
-    /**
-     * Clear all data from the collection
-     */
-    clear(): Promise<void>;
-}
-export declare const vectorStore: VectorStore;
-export {};
-//# sourceMappingURL=vectorStore.d.ts.map

package/dist/db/vectorStore.js

@@ -1,196 +0,0 @@
-import { ChromaClient } from "chromadb";
-import { config, logger } from "../utils/index.js";
-import { embeddingGenerator } from "../pipeline/embeddings.js";
-class VectorStore {
-    client = null;
-    collection = null;
-    collectionName = "midnight-code";
-    initialized = false;
-    /**
-     * Initialize the vector store connection
-     */
-    async initialize() {
-        if (this.initialized)
-            return;
-        try {
-            this.client = new ChromaClient({
-                path: config.chromaUrl,
-            });
-            // Get or create the collection
-            this.collection = await this.client.getOrCreateCollection({
-                name: this.collectionName,
-                metadata: {
-                    description: "Midnight blockchain code and documentation",
-                },
-            });
-            this.initialized = true;
-            logger.info("Vector store initialized successfully");
-        }
-        catch (error) {
-            logger.error("Failed to initialize vector store", {
-                error: String(error),
-            });
-            // Continue without vector store - use fallback search
-            logger.warn("Vector store unavailable, using in-memory fallback");
-        }
-    }
-    /**
-     * Add documents to the vector store
-     */
-    async addDocuments(documents) {
-        if (!this.collection) {
-            logger.warn("Vector store not initialized, skipping document storage");
-            return;
-        }
-        try {
-            const ids = documents.map((d) => d.id);
-            const embeddings = documents.map((d) => d.embedding);
-            const metadatas = documents.map((d) => ({
-                repository: d.metadata.repository,
-                filePath: d.metadata.filePath,
-                language: d.metadata.language,
-                startLine: d.metadata.startLine,
-                endLine: d.metadata.endLine,
-                codeType: d.metadata.codeType,
-                codeName: d.metadata.codeName,
-                isPublic: d.metadata.isPublic,
-            }));
-            const documentContents = documents.map((d) => d.content);
-            await this.collection.add({
-                ids,
-                embeddings,
-                metadatas,
-                documents: documentContents,
-            });
-            logger.debug(`Added ${documents.length} documents to vector store`);
-        }
-        catch (error) {
-            logger.error("Failed to add documents to vector store", {
-                error: String(error),
-            });
-            throw error;
-        }
-    }
-    /**
-     * Search for similar documents
-     */
-    async search(query, limit = 10, filter) {
-        if (!this.collection) {
-            logger.warn("Vector store not initialized, returning empty results");
-            return [];
-        }
-        try {
-            // Generate embedding for the query
-            const queryEmbedding = await embeddingGenerator.generateEmbedding(query);
-            // Build where filter
-            const whereFilter = {};
-            if (filter?.repository) {
-                whereFilter.repository = filter.repository;
-            }
-            if (filter?.language) {
-                whereFilter.language = filter.language;
-            }
-            if (filter?.codeType) {
-                whereFilter.codeType = filter.codeType;
-            }
-            if (filter?.isPublic !== undefined) {
-                whereFilter.isPublic = filter.isPublic;
-            }
-            const results = await this.collection.query({
-                queryEmbeddings: [queryEmbedding.embedding],
-                nResults: limit,
-                where: Object.keys(whereFilter).length > 0 ? whereFilter : undefined,
-            });
-            // Format results
-            const searchResults = [];
-            if (results.ids[0] && results.documents[0] && results.metadatas[0]) {
-                for (let i = 0; i < results.ids[0].length; i++) {
-                    const metadata = results.metadatas[0][i];
-                    searchResults.push({
-                        id: results.ids[0][i],
-                        content: results.documents[0][i] || "",
-                        score: results.distances ? 1 - (results.distances[0][i] || 0) : 0,
-                        metadata,
-                    });
-                }
-            }
-            return searchResults;
-        }
-        catch (error) {
-            logger.error("Search failed", { error: String(error) });
-            return [];
-        }
-    }
-    /**
-     * Delete documents by file path
-     */
-    async deleteByPath(repository, filePath) {
-        if (!this.collection)
-            return;
-        try {
-            await this.collection.delete({
-                where: {
-                    repository,
-                    filePath,
-                },
-            });
-            logger.debug(`Deleted documents for ${repository}:${filePath}`);
-        }
-        catch (error) {
-            logger.error("Failed to delete documents", { error: String(error) });
-        }
-    }
-    /**
-     * Delete all documents for a repository
-     */
-    async deleteRepository(repository) {
-        if (!this.collection)
-            return;
-        try {
-            await this.collection.delete({
-                where: { repository },
-            });
-            logger.info(`Deleted all documents for repository ${repository}`);
-        }
-        catch (error) {
-            logger.error("Failed to delete repository documents", {
-                error: String(error),
-            });
-        }
-    }
-    /**
-     * Get collection statistics
-     */
-    async getStats() {
-        if (!this.collection) {
-            return { count: 0 };
-        }
-        try {
-            const count = await this.collection.count();
-            return { count };
-        }
-        catch (error) {
-            logger.error("Failed to get stats", { error: String(error) });
-            return { count: 0 };
-        }
-    }
-    /**
-     * Clear all data from the collection
-     */
-    async clear() {
-        if (!this.client)
-            return;
-        try {
-            await this.client.deleteCollection({ name: this.collectionName });
-            this.collection = await this.client.getOrCreateCollection({
-                name: this.collectionName,
-            });
-            logger.info("Vector store cleared");
-        }
-        catch (error) {
-            logger.error("Failed to clear vector store", { error: String(error) });
-        }
-    }
-}
-export const vectorStore = new VectorStore();
-//# sourceMappingURL=vectorStore.js.map