midnight-mcp 0.1.40 → 0.2.1

package/dist/resources/content/index.d.ts

@@ -1,6 +0,0 @@
-/**
- * Content barrel export
- */
-export { EMBEDDED_DOCS } from "./docs-content.js";
-export { EMBEDDED_CODE } from "./code-content.js";
-//# sourceMappingURL=index.d.ts.map

package/dist/resources/content/index.js

@@ -1,6 +0,0 @@
-/**
- * Content barrel export
- */
-export { EMBEDDED_DOCS } from "./docs-content.js";
-export { EMBEDDED_CODE } from "./code-content.js";
-//# sourceMappingURL=index.js.map

package/dist/resources/docs.d.ts

@@ -1,15 +0,0 @@
-/**
- * Documentation resources
- * Provides access to Midnight documentation via MCP resources
- */
-import type { ResourceDefinition } from "./schemas.js";
-export declare const documentationResources: ResourceDefinition[];
-/**
- * Get documentation content by URI
- */
-export declare function getDocumentation(uri: string): Promise<string | null>;
-/**
- * List all available documentation resources
- */
-export declare function listDocumentationResources(): ResourceDefinition[];
-//# sourceMappingURL=docs.d.ts.map

package/dist/resources/docs.js

@@ -1,98 +0,0 @@
-/**
- * Documentation resources
- * Provides access to Midnight documentation via MCP resources
- */
-import { githubClient } from "../pipeline/index.js";
-import { logger } from "../utils/index.js";
-import { EMBEDDED_DOCS } from "./content/index.js";
-// Documentation resource URIs
-// NOTE: Only resources with embedded content are listed here.
-// For other docs (glossary, Zswap, Kachina, etc.), use search_docs tool
-// which queries the indexed Vector DB for the full midnight-docs repo.
-export const documentationResources = [
-    {
-        uri: "midnight://docs/compact-reference",
-        name: "Compact Language Reference",
-        description: "Quick reference for Compact syntax, types, circuits, and witnesses",
-        mimeType: "text/markdown",
-    },
-    {
-        uri: "midnight://docs/sdk-api",
-        name: "TypeScript SDK API",
-        description: "TypeScript SDK API reference with type signatures and usage examples",
-        mimeType: "text/markdown",
-    },
-    {
-        uri: "midnight://docs/openzeppelin",
-        name: "OpenZeppelin Contracts for Compact",
-        description: "Official OpenZeppelin library - tokens, access control, security patterns",
-        mimeType: "text/markdown",
-    },
-    {
-        uri: "midnight://docs/openzeppelin/token",
-        name: "OpenZeppelin FungibleToken",
-        description: "Privacy-preserving token standard for Midnight",
-        mimeType: "text/markdown",
-    },
-    {
-        uri: "midnight://docs/openzeppelin/access",
-        name: "OpenZeppelin Access Control",
-        description: "Ownable, roles, and access control patterns",
-        mimeType: "text/markdown",
-    },
-    {
-        uri: "midnight://docs/openzeppelin/security",
-        name: "OpenZeppelin Security",
-        description: "Pausable and security patterns",
-        mimeType: "text/markdown",
-    },
-    {
-        uri: "midnight://docs/tokenomics",
-        name: "Tokenomics Summary",
-        description: "Curated summary: NIGHT token, DUST resource, block rewards, Glacier Drop distribution",
-        mimeType: "text/markdown",
-    },
-    {
-        uri: "midnight://docs/wallet-integration",
-        name: "Wallet Integration Guide",
-        description: "DApp Connector API for Midnight Lace wallet - React hooks, TypeScript types",
-        mimeType: "text/markdown",
-    },
-    {
-        uri: "midnight://docs/common-errors",
-        name: "Common Errors & Solutions",
-        description: "Troubleshooting guide: compiler errors, SDK errors, deployment issues with fixes",
-        mimeType: "text/markdown",
-    },
-];
-/**
- * Get documentation content by URI
- */
-export async function getDocumentation(uri) {
-    // Check embedded docs first
-    if (EMBEDDED_DOCS[uri]) {
-        return EMBEDDED_DOCS[uri];
-    }
-    // Try to fetch from GitHub if it's a doc path
-    if (uri.startsWith("midnight://docs/")) {
-        const docPath = uri.replace("midnight://docs/", "");
-        try {
-            // Try to fetch from midnight-docs repo
-            const file = await githubClient.getFileContent("midnightntwrk", "midnight-docs", `docs/${docPath}.md`);
-            if (file) {
-                return file.content;
-            }
-        }
-        catch (error) {
-            logger.warn(`Could not fetch doc from GitHub: ${uri}`);
-        }
-    }
-    return null;
-}
-/**
- * List all available documentation resources
- */
-export function listDocumentationResources() {
-    return documentationResources;
-}
-//# sourceMappingURL=docs.js.map

package/dist/resources/index.d.ts

@@ -1,6 +0,0 @@
-export { documentationResources, getDocumentation, listDocumentationResources, } from "./docs.js";
-export { codeResources, getCode, listCodeResources } from "./code.js";
-export { schemaResources, getSchema, listSchemaResources } from "./schemas.js";
-export type { ResourceDefinition } from "./schemas.js";
-export declare const allResources: import("./schemas.js").ResourceDefinition[];
-//# sourceMappingURL=index.d.ts.map

package/dist/resources/index.js

@@ -1,13 +0,0 @@
-export { documentationResources, getDocumentation, listDocumentationResources, } from "./docs.js";
-export { codeResources, getCode, listCodeResources } from "./code.js";
-export { schemaResources, getSchema, listSchemaResources } from "./schemas.js";
-// Combine all resources
-import { documentationResources } from "./docs.js";
-import { codeResources } from "./code.js";
-import { schemaResources } from "./schemas.js";
-export const allResources = [
-    ...documentationResources,
-    ...codeResources,
-    ...schemaResources,
-];
-//# sourceMappingURL=index.js.map

package/dist/resources/schemas.d.ts

@@ -1,16 +0,0 @@
-export interface ResourceDefinition {
-    uri: string;
-    name: string;
-    description: string;
-    mimeType: string;
-}
-export declare const schemaResources: ResourceDefinition[];
-/**
- * Get schema content by URI
- */
-export declare function getSchema(uri: string): object | null;
-/**
- * List all available schema resources
- */
-export declare function listSchemaResources(): ResourceDefinition[];
-//# sourceMappingURL=schemas.d.ts.map

package/dist/resources/schemas.js

@@ -1,407 +0,0 @@
-// Schema resources
-export const schemaResources = [
-    {
-        uri: "midnight://schema/compact-ast",
-        name: "Compact AST Schema",
-        description: "JSON schema for Compact Abstract Syntax Tree structures",
-        mimeType: "application/json",
-    },
-    {
-        uri: "midnight://schema/transaction",
-        name: "Transaction Schema",
-        description: "Transaction format schema for Midnight network",
-        mimeType: "application/json",
-    },
-    {
-        uri: "midnight://schema/proof",
-        name: "Proof Schema",
-        description: "ZK proof format schema",
-        mimeType: "application/json",
-    },
-];
-// Embedded schemas
-const EMBEDDED_SCHEMAS = {
-    "midnight://schema/compact-ast": {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        title: "Compact AST",
-        description: "Abstract Syntax Tree for Compact smart contracts",
-        type: "object",
-        definitions: {
-            LedgerDeclaration: {
-                type: "object",
-                properties: {
-                    type: { const: "LedgerDeclaration" },
-                    fields: {
-                        type: "array",
-                        items: { $ref: "#/definitions/LedgerField" },
-                    },
-                },
-                required: ["type", "fields"],
-            },
-            LedgerField: {
-                type: "object",
-                properties: {
-                    name: { type: "string" },
-                    fieldType: { type: "string" },
-                    isPrivate: { type: "boolean" },
-                    annotations: { type: "array", items: { type: "string" } },
-                },
-                required: ["name", "fieldType"],
-            },
-            CircuitDeclaration: {
-                type: "object",
-                properties: {
-                    type: { const: "CircuitDeclaration" },
-                    name: { type: "string" },
-                    isExported: { type: "boolean" },
-                    parameters: {
-                        type: "array",
-                        items: { $ref: "#/definitions/Parameter" },
-                    },
-                    returnType: { type: "string" },
-                    body: { $ref: "#/definitions/BlockStatement" },
-                },
-                required: ["type", "name", "parameters", "body"],
-            },
-            WitnessDeclaration: {
-                type: "object",
-                properties: {
-                    type: { const: "WitnessDeclaration" },
-                    name: { type: "string" },
-                    parameters: {
-                        type: "array",
-                        items: { $ref: "#/definitions/Parameter" },
-                    },
-                    returnType: { type: "string" },
-                    body: { $ref: "#/definitions/BlockStatement" },
-                },
-                required: ["type", "name", "parameters", "body"],
-            },
-            Parameter: {
-                type: "object",
-                properties: {
-                    name: { type: "string" },
-                    paramType: { type: "string" },
-                    isPrivate: { type: "boolean" },
-                },
-                required: ["name", "paramType"],
-            },
-            BlockStatement: {
-                type: "object",
-                properties: {
-                    type: { const: "BlockStatement" },
-                    statements: {
-                        type: "array",
-                        items: { $ref: "#/definitions/Statement" },
-                    },
-                },
-                required: ["type", "statements"],
-            },
-            Statement: {
-                oneOf: [
-                    { $ref: "#/definitions/VariableDeclaration" },
-                    { $ref: "#/definitions/AssertStatement" },
-                    { $ref: "#/definitions/ReturnStatement" },
-                    { $ref: "#/definitions/ExpressionStatement" },
-                ],
-            },
-            VariableDeclaration: {
-                type: "object",
-                properties: {
-                    type: { const: "VariableDeclaration" },
-                    name: { type: "string" },
-                    varType: { type: "string" },
-                    initializer: { $ref: "#/definitions/Expression" },
-                },
-                required: ["type", "name"],
-            },
-            AssertStatement: {
-                type: "object",
-                properties: {
-                    type: { const: "AssertStatement" },
-                    condition: { $ref: "#/definitions/Expression" },
-                    message: { type: "string" },
-                },
-                required: ["type", "condition"],
-            },
-            ReturnStatement: {
-                type: "object",
-                properties: {
-                    type: { const: "ReturnStatement" },
-                    value: { $ref: "#/definitions/Expression" },
-                },
-                required: ["type"],
-            },
-            ExpressionStatement: {
-                type: "object",
-                properties: {
-                    type: { const: "ExpressionStatement" },
-                    expression: { $ref: "#/definitions/Expression" },
-                },
-                required: ["type", "expression"],
-            },
-            Expression: {
-                oneOf: [
-                    { $ref: "#/definitions/BinaryExpression" },
-                    { $ref: "#/definitions/CallExpression" },
-                    { $ref: "#/definitions/MemberExpression" },
-                    { $ref: "#/definitions/Identifier" },
-                    { $ref: "#/definitions/Literal" },
-                ],
-            },
-            BinaryExpression: {
-                type: "object",
-                properties: {
-                    type: { const: "BinaryExpression" },
-                    operator: { type: "string" },
-                    left: { $ref: "#/definitions/Expression" },
-                    right: { $ref: "#/definitions/Expression" },
-                },
-                required: ["type", "operator", "left", "right"],
-            },
-            CallExpression: {
-                type: "object",
-                properties: {
-                    type: { const: "CallExpression" },
-                    callee: { $ref: "#/definitions/Expression" },
-                    arguments: {
-                        type: "array",
-                        items: { $ref: "#/definitions/Expression" },
-                    },
-                },
-                required: ["type", "callee", "arguments"],
-            },
-            MemberExpression: {
-                type: "object",
-                properties: {
-                    type: { const: "MemberExpression" },
-                    object: { $ref: "#/definitions/Expression" },
-                    property: { type: "string" },
-                },
-                required: ["type", "object", "property"],
-            },
-            Identifier: {
-                type: "object",
-                properties: {
-                    type: { const: "Identifier" },
-                    name: { type: "string" },
-                },
-                required: ["type", "name"],
-            },
-            Literal: {
-                type: "object",
-                properties: {
-                    type: { const: "Literal" },
-                    value: {},
-                    raw: { type: "string" },
-                },
-                required: ["type", "value"],
-            },
-        },
-        properties: {
-            type: { const: "Program" },
-            imports: {
-                type: "array",
-                items: { type: "string" },
-            },
-            ledger: { $ref: "#/definitions/LedgerDeclaration" },
-            circuits: {
-                type: "array",
-                items: { $ref: "#/definitions/CircuitDeclaration" },
-            },
-            witnesses: {
-                type: "array",
-                items: { $ref: "#/definitions/WitnessDeclaration" },
-            },
-            types: {
-                type: "array",
-                items: {
-                    type: "object",
-                    properties: {
-                        name: { type: "string" },
-                        definition: { type: "string" },
-                    },
-                },
-            },
-        },
-        required: ["type"],
-    },
-    "midnight://schema/transaction": {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        title: "Midnight Transaction",
-        description: "Transaction format for Midnight network",
-        type: "object",
-        properties: {
-            version: {
-                type: "integer",
-                description: "Transaction format version",
-            },
-            hash: {
-                type: "string",
-                description: "Transaction hash (hex)",
-                pattern: "^0x[a-fA-F0-9]{64}$",
-            },
-            contractAddress: {
-                type: "string",
-                description: "Target contract address",
-            },
-            circuitName: {
-                type: "string",
-                description: "Name of the circuit being called",
-            },
-            inputs: {
-                type: "object",
-                description: "Public inputs to the circuit",
-                additionalProperties: true,
-            },
-            proof: {
-                $ref: "#/definitions/Proof",
-            },
-            publicOutputs: {
-                type: "array",
-                description: "Public outputs from circuit execution",
-                items: {},
-            },
-            stateChanges: {
-                type: "array",
-                items: { $ref: "#/definitions/StateChange" },
-            },
-            timestamp: {
-                type: "integer",
-                description: "Transaction timestamp (Unix)",
-            },
-            sender: {
-                type: "string",
-                description: "Transaction sender address",
-            },
-            nonce: {
-                type: "integer",
-                description: "Transaction nonce",
-            },
-            fee: {
-                type: "string",
-                description: "Transaction fee",
-            },
-        },
-        definitions: {
-            Proof: {
-                type: "object",
-                properties: {
-                    type: {
-                        type: "string",
-                        enum: ["groth16", "plonk"],
-                    },
-                    data: {
-                        type: "string",
-                        description: "Base64 encoded proof data",
-                    },
-                    publicInputs: {
-                        type: "array",
-                        items: { type: "string" },
-                    },
-                },
-                required: ["type", "data", "publicInputs"],
-            },
-            StateChange: {
-                type: "object",
-                properties: {
-                    type: {
-                        type: "string",
-                        enum: ["insert", "update", "delete"],
-                    },
-                    path: {
-                        type: "string",
-                        description: "State path being modified",
-                    },
-                    oldValue: {
-                        description: "Previous value (for updates/deletes)",
-                    },
-                    newValue: {
-                        description: "New value (for inserts/updates)",
-                    },
-                },
-                required: ["type", "path"],
-            },
-        },
-        required: ["version", "contractAddress", "circuitName", "proof"],
-    },
-    "midnight://schema/proof": {
-        $schema: "http://json-schema.org/draft-07/schema#",
-        title: "Midnight ZK Proof",
-        description: "Zero-knowledge proof format",
-        type: "object",
-        properties: {
-            proofSystem: {
-                type: "string",
-                enum: ["groth16", "plonk", "halo2"],
-                description: "Proof system used",
-            },
-            curve: {
-                type: "string",
-                enum: ["bn254", "bls12-381"],
-                description: "Elliptic curve used",
-            },
-            proof: {
-                type: "object",
-                properties: {
-                    a: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "Proof element A (G1 point)",
-                    },
-                    b: {
-                        type: "array",
-                        items: {
-                            type: "array",
-                            items: { type: "string" },
-                        },
-                        description: "Proof element B (G2 point)",
-                    },
-                    c: {
-                        type: "array",
-                        items: { type: "string" },
-                        description: "Proof element C (G1 point)",
-                    },
-                },
-                required: ["a", "b", "c"],
-            },
-            publicInputs: {
-                type: "array",
-                items: { type: "string" },
-                description: "Public inputs to the circuit",
-            },
-            publicOutputs: {
-                type: "array",
-                items: { type: "string" },
-                description: "Public outputs from the circuit",
-            },
-            verificationKey: {
-                type: "string",
-                description: "Reference to verification key",
-            },
-            metadata: {
-                type: "object",
-                properties: {
-                    circuitName: { type: "string" },
-                    contractAddress: { type: "string" },
-                    generatedAt: { type: "integer" },
-                    proverVersion: { type: "string" },
-                },
-            },
-        },
-        required: ["proofSystem", "proof", "publicInputs"],
-    },
-};
-/**
- * Get schema content by URI
- */
-export function getSchema(uri) {
-    return EMBEDDED_SCHEMAS[uri] || null;
-}
-/**
- * List all available schema resources
- */
-export function listSchemaResources() {
-    return schemaResources;
-}
-//# sourceMappingURL=schemas.js.map

package/dist/scripts/index-repos.d.ts

@@ -1,12 +0,0 @@
-#!/usr/bin/env node
-/**
- * Repository Indexing Script
- *
- * Run this script to index all Midnight repositories into the vector database.
- *
- * Usage:
- *   npm run index                    # Index all repos
- *   npm run index -- --repo compact  # Index specific repo
- */
-export {};
-//# sourceMappingURL=index-repos.d.ts.map

package/dist/scripts/index-repos.js

@@ -1,53 +0,0 @@
-#!/usr/bin/env node
-/**
- * Repository Indexing Script
- *
- * Run this script to index all Midnight repositories into the vector database.
- *
- * Usage:
- *   npm run index                    # Index all repos
- *   npm run index -- --repo compact  # Index specific repo
- */
-import { indexAllRepositories, indexRepository } from "../pipeline/index.js";
-import { DEFAULT_REPOSITORIES, logger } from "../utils/index.js";
-import { vectorStore } from "../db/index.js";
-async function main() {
-    const args = process.argv.slice(2);
-    const repoArg = args.find((a) => a.startsWith("--repo="));
-    const specificRepo = repoArg?.split("=")[1];
-    logger.info("Starting repository indexing...");
-    // Initialize vector store
-    try {
-        await vectorStore.initialize();
-    }
-    catch (error) {
-        logger.error("Failed to initialize vector store", { error: String(error) });
-        logger.info("Make sure ChromaDB is running: docker run -p 8000:8000 chromadb/chroma");
-        process.exit(1);
-    }
-    if (specificRepo) {
-        // Index specific repository
-        const repoConfig = DEFAULT_REPOSITORIES.find((r) => r.repo.toLowerCase() === specificRepo.toLowerCase());
-        if (!repoConfig) {
-            logger.error(`Unknown repository: ${specificRepo}`);
-            logger.info(`Available repositories: ${DEFAULT_REPOSITORIES.map((r) => r.repo).join(", ")}`);
-            process.exit(1);
-        }
-        logger.info(`Indexing repository: ${repoConfig.owner}/${repoConfig.repo}`);
-        const result = await indexRepository(repoConfig);
-        logger.info("Indexing complete", result);
-    }
-    else {
-        // Index all repositories
-        const stats = await indexAllRepositories();
-        logger.info("Full indexing complete", stats);
-    }
-    // Print statistics
-    const dbStats = await vectorStore.getStats();
-    logger.info(`Vector store now contains ${dbStats.count} documents`);
-}
-main().catch((error) => {
-    logger.error("Indexing failed", { error: String(error) });
-    process.exit(1);
-});
-//# sourceMappingURL=index-repos.js.map

package/dist/server.d.ts

@@ -1,43 +0,0 @@
-import { Server } from "@modelcontextprotocol/sdk/server/index.js";
-import { LoggingLevel } from "@modelcontextprotocol/sdk/types.js";
-/**
- * Get update warning if outdated (to include in responses)
- */
-export declare function getUpdateWarning(): string | null;
-/**
- * Clear all subscriptions (useful for server restart/testing)
- */
-export declare function clearSubscriptions(): void;
-/**
- * Mark server as connected (safe to send notifications)
- */
-export declare function setServerConnected(connected: boolean): void;
-/**
- * Send a log message to the MCP client
- * This allows clients to see server logs for debugging
- */
-export declare function sendLogToClient(level: LoggingLevel, loggerName: string, data: unknown): void;
-/**
- * Send a progress notification to the MCP client
- * Used for long-running operations like compound tools
- */
-export declare function sendProgressNotification(progressToken: string | number, progress: number, total?: number, message?: string): void;
-export declare function createServer(): Server;
-/**
- * Notify subscribers when a resource changes
- * Call this when re-indexing or when docs are updated
- */
-export declare function notifyResourceUpdate(server: Server, uri: string): void;
-/**
- * Get the list of active subscriptions
- */
-export declare function getActiveSubscriptions(): string[];
-/**
- * Initialize the server and vector store
- */
-export declare function initializeServer(): Promise<Server>;
-/**
- * Start the server with stdio transport
- */
-export declare function startServer(): Promise<void>;
-//# sourceMappingURL=server.d.ts.map