midnight-mcp 0.1.0 → 0.1.2

package/dist/resources/index.d.ts

@@ -1,6 +1,6 @@
 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 "./docs.js";
-export declare const allResources: import("./docs.js").ResourceDefinition[];
+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,6 +1,6 @@
 export { documentationResources, getDocumentation, listDocumentationResources, } from "./docs.js";
-export { codeResources, getCode, listCodeResources, } from "./code.js";
-export { schemaResources, getSchema, listSchemaResources, } from "./schemas.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";

package/dist/server.d.ts

@@ -1,4 +1,8 @@
 import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+/**
+ * Clear all subscriptions (useful for server restart/testing)
+ */
+export declare function clearSubscriptions(): void;
 /**
  * Create and configure the MCP server
  */

package/dist/server.js

@@ -15,6 +15,13 @@ const SERVER_INFO = {
 };
 // Resource subscriptions tracking
 const resourceSubscriptions = new Set();
+/**
+ * Clear all subscriptions (useful for server restart/testing)
+ */
+export function clearSubscriptions() {
+    resourceSubscriptions.clear();
+    logger.debug("Subscriptions cleared");
+}
 // Resource templates for parameterized resources (RFC 6570 URI Templates)
 const resourceTemplates = [
     {
@@ -295,7 +302,7 @@ function registerSubscriptionHandlers(server) {
         const isValid = validPrefixes.some((prefix) => uri.startsWith(prefix));
         if (!isValid) {
             logger.warn(`Invalid subscription URI: ${uri}`);
-            return {};
+            throw new Error(`Invalid subscription URI: ${uri}. Valid prefixes: ${validPrefixes.join(", ")}`);
         }
         resourceSubscriptions.add(uri);
         logger.debug(`Active subscriptions: ${resourceSubscriptions.size}`);
@@ -355,7 +362,17 @@ function setupSampling(server) {
             }, 
             // Use a schema that matches the expected response
             {
-                parse: (data) => data,
+                parse: (data) => {
+                    const response = data;
+                    // Basic validation of expected response structure
+                    if (!response || typeof response !== "object") {
+                        throw new Error("Invalid sampling response: expected object");
+                    }
+                    if (!response.content || typeof response.content !== "object") {
+                        throw new Error("Invalid sampling response: missing content");
+                    }
+                    return response;
+                },
                 _def: { typeName: "SamplingResponse" },
             });
             return response;

package/dist/services/sampling.js

@@ -191,10 +191,31 @@ Respond in JSON format:
             maxTokens: 4096,
             temperature: 0.2,
         });
-        // Parse JSON response
+        // Parse JSON response with error handling
         const jsonMatch = response.match(/\{[\s\S]*\}/);
         if (jsonMatch) {
-            return JSON.parse(jsonMatch[0]);
+            try {
+                const parsed = JSON.parse(jsonMatch[0]);
+                // Validate expected structure
+                return {
+                    summary: typeof parsed.summary === "string"
+                        ? parsed.summary
+                        : "Review complete",
+                    issues: Array.isArray(parsed.issues) ? parsed.issues : [],
+                    improvedCode: typeof parsed.improvedCode === "string"
+                        ? parsed.improvedCode
+                        : undefined,
+                };
+            }
+            catch (parseError) {
+                logger.warn("Failed to parse JSON from LLM response", {
+                    error: String(parseError),
+                });
+                return {
+                    summary: response,
+                    issues: [],
+                };
+            }
         }
         return {
             summary: response,

package/dist/tools/analyze.js

@@ -230,46 +230,77 @@ function getPrivacyConsiderations(circuit) {
     }
     return considerations;
 }
-// Output schemas for analysis tools
+// Output schemas for analysis tools - aligned with actual function return types
 const analyzeContractOutputSchema = {
     type: "object",
     properties: {
-        name: { type: "string", description: "Contract name" },
-        summary: { type: "string", description: "Brief contract summary" },
-        ledgerState: {
-            type: "array",
-            description: "Ledger state fields",
-            items: {
-                type: "object",
-                properties: {
-                    name: { type: "string" },
-                    type: { type: "string" },
-                    isPrivate: { type: "boolean" },
-                },
+        summary: {
+            type: "object",
+            description: "Summary statistics of the contract",
+            properties: {
+                hasLedger: { type: "boolean" },
+                hasCircuits: { type: "boolean" },
+                hasWitnesses: { type: "boolean" },
+                totalLines: { type: "number" },
+                publicCircuits: { type: "number" },
+                privateCircuits: { type: "number" },
+                publicState: { type: "number" },
+                privateState: { type: "number" },
             },
         },
-        circuits: {
-            type: "array",
-            description: "Circuit definitions",
-            items: {
-                type: "object",
-                properties: {
-                    name: { type: "string" },
-                    isPublic: { type: "boolean" },
-                    parameters: { type: "array", items: { type: "object" } },
-                    purpose: { type: "string" },
+        structure: {
+            type: "object",
+            description: "Contract structure breakdown",
+            properties: {
+                imports: { type: "array", items: { type: "string" } },
+                exports: { type: "array", items: { type: "string" } },
+                ledger: {
+                    type: "array",
+                    description: "Ledger state fields",
+                    items: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" },
+                            type: { type: "string" },
+                            isPrivate: { type: "boolean" },
+                        },
+                    },
                 },
-            },
-        },
-        witnesses: {
-            type: "array",
-            description: "Witness functions",
-            items: {
-                type: "object",
-                properties: {
-                    name: { type: "string" },
-                    returnType: { type: "string" },
-                    purpose: { type: "string" },
+                circuits: {
+                    type: "array",
+                    description: "Circuit definitions",
+                    items: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" },
+                            isPublic: { type: "boolean" },
+                            parameters: { type: "array", items: { type: "object" } },
+                            returnType: { type: "string" },
+                        },
+                    },
+                },
+                witnesses: {
+                    type: "array",
+                    description: "Witness functions",
+                    items: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" },
+                            parameters: { type: "array", items: { type: "object" } },
+                            returnType: { type: "string" },
+                        },
+                    },
+                },
+                types: {
+                    type: "array",
+                    description: "Type definitions",
+                    items: {
+                        type: "object",
+                        properties: {
+                            name: { type: "string" },
+                            definition: { type: "string" },
+                        },
+                    },
                 },
             },
         },
@@ -294,31 +325,14 @@ const analyzeContractOutputSchema = {
             description: "Recommendations for improvement",
         },
     },
-    required: ["summary", "circuits"],
+    required: ["summary", "structure", "securityFindings", "recommendations"],
     description: "Detailed contract analysis with security findings",
 };
 const explainCircuitOutputSchema = {
     type: "object",
     properties: {
-        name: { type: "string", description: "Circuit name" },
-        type: {
-            type: "string",
-            description: "Type: circuit or witness",
-        },
+        circuitName: { type: "string", description: "Circuit name" },
         isPublic: { type: "boolean", description: "Whether it's exported" },
-        plainEnglishExplanation: {
-            type: "string",
-            description: "Plain language explanation",
-        },
-        zkProofImplications: {
-            type: "string",
-            description: "Zero-knowledge proof implications",
-        },
-        privacyConsiderations: {
-            type: "array",
-            items: { type: "string" },
-            description: "Privacy-related considerations",
-        },
         parameters: {
             type: "array",
             items: {
@@ -326,13 +340,37 @@ const explainCircuitOutputSchema = {
                 properties: {
                     name: { type: "string" },
                     type: { type: "string" },
-                    description: { type: "string" },
                 },
             },
+            description: "Circuit parameters",
+        },
+        returnType: { type: "string", description: "Return type" },
+        explanation: {
+            type: "string",
+            description: "Plain language explanation",
+        },
+        operations: {
+            type: "array",
+            items: { type: "string" },
+            description: "Operations performed by the circuit",
+        },
+        zkImplications: {
+            type: "array",
+            items: { type: "string" },
+            description: "Zero-knowledge proof implications",
+        },
+        privacyConsiderations: {
+            type: "array",
+            items: { type: "string" },
+            description: "Privacy-related considerations",
         },
-        returnType: { type: "string" },
     },
-    required: ["name", "plainEnglishExplanation"],
+    required: [
+        "circuitName",
+        "explanation",
+        "zkImplications",
+        "privacyConsiderations",
+    ],
     description: "Detailed circuit explanation with privacy analysis",
 };
 // Tool definitions for MCP

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

@@ -0,0 +1,19 @@
+/**
+ * Repository constants
+ * Aliases, example definitions, and configuration data
+ */
+export declare const REPO_ALIASES: Record<string, {
+    owner: string;
+    repo: string;
+}>;
+export interface ExampleDefinition {
+    name: string;
+    repository: string;
+    description: string;
+    category: string;
+    complexity: "beginner" | "intermediate" | "advanced";
+    mainFile: string;
+    features: string[];
+}
+export declare const EXAMPLES: ExampleDefinition[];
+//# sourceMappingURL=constants.d.ts.map

package/dist/tools/repository/constants.js

@@ -0,0 +1,103 @@
+/**
+ * Repository constants
+ * Aliases, example definitions, and configuration data
+ */
+// Repository name mapping
+export const REPO_ALIASES = {
+    // Core Language & SDK
+    compact: { owner: "midnightntwrk", repo: "compact" },
+    "midnight-js": { owner: "midnightntwrk", repo: "midnight-js" },
+    js: { owner: "midnightntwrk", repo: "midnight-js" },
+    sdk: { owner: "midnightntwrk", repo: "midnight-js" },
+    // Documentation
+    docs: { owner: "midnightntwrk", repo: "midnight-docs" },
+    "midnight-docs": { owner: "midnightntwrk", repo: "midnight-docs" },
+    // Example DApps
+    "example-counter": { owner: "midnightntwrk", repo: "example-counter" },
+    counter: { owner: "midnightntwrk", repo: "example-counter" },
+    "example-bboard": { owner: "midnightntwrk", repo: "example-bboard" },
+    bboard: { owner: "midnightntwrk", repo: "example-bboard" },
+    "example-dex": { owner: "midnightntwrk", repo: "example-dex" },
+    dex: { owner: "midnightntwrk", repo: "example-dex" },
+    // Developer Tools
+    "create-mn-app": { owner: "midnightntwrk", repo: "create-mn-app" },
+    "midnight-wallet": { owner: "midnightntwrk", repo: "midnight-wallet" },
+    wallet: { owner: "midnightntwrk", repo: "midnight-wallet" },
+    // Infrastructure
+    "midnight-indexer": { owner: "midnightntwrk", repo: "midnight-indexer" },
+    indexer: { owner: "midnightntwrk", repo: "midnight-indexer" },
+    "midnight-node-docker": {
+        owner: "midnightntwrk",
+        repo: "midnight-node-docker",
+    },
+    node: { owner: "midnightntwrk", repo: "midnight-node-docker" },
+    // APIs & Connectors
+    "midnight-dapp-connector-api": {
+        owner: "midnightntwrk",
+        repo: "midnight-dapp-connector-api",
+    },
+    connector: { owner: "midnightntwrk", repo: "midnight-dapp-connector-api" },
+    // Tooling
+    "compact-tree-sitter": {
+        owner: "midnightntwrk",
+        repo: "compact-tree-sitter",
+    },
+    // Community
+    "midnight-awesome-dapps": {
+        owner: "midnightntwrk",
+        repo: "midnight-awesome-dapps",
+    },
+    awesome: { owner: "midnightntwrk", repo: "midnight-awesome-dapps" },
+    "contributor-hub": { owner: "midnightntwrk", repo: "contributor-hub" },
+    // Partner Libraries (OpenZeppelin)
+    "compact-contracts": { owner: "OpenZeppelin", repo: "compact-contracts" },
+    openzeppelin: { owner: "OpenZeppelin", repo: "compact-contracts" },
+    oz: { owner: "OpenZeppelin", repo: "compact-contracts" },
+};
+export const EXAMPLES = [
+    {
+        name: "Counter",
+        repository: "midnightntwrk/example-counter",
+        description: "Simple counter contract demonstrating basic Compact concepts. Perfect for learning ledger state, circuits, and witnesses.",
+        category: "counter",
+        complexity: "beginner",
+        mainFile: "contract/src/counter.compact",
+        features: [
+            "Ledger state management",
+            "Basic circuit definition",
+            "Counter increment/decrement",
+            "TypeScript integration",
+        ],
+    },
+    {
+        name: "Bulletin Board",
+        repository: "midnightntwrk/example-bboard",
+        description: "Full DApp example with CLI and React UI. Demonstrates posting messages with privacy features.",
+        category: "bboard",
+        complexity: "intermediate",
+        mainFile: "contract/src/bboard.compact",
+        features: [
+            "Private messaging",
+            "React frontend",
+            "CLI interface",
+            "Wallet integration",
+            "Disclose operations",
+        ],
+    },
+    {
+        name: "DEX (Decentralized Exchange)",
+        repository: "midnightntwrk/example-dex",
+        description: "Advanced DApp example showing token swaps and liquidity pools with privacy-preserving transactions.",
+        category: "dex",
+        complexity: "advanced",
+        mainFile: "contract/src/dex.compact",
+        features: [
+            "Token swaps",
+            "Liquidity pools",
+            "Privacy-preserving trades",
+            "Price calculations",
+            "Advanced state management",
+        ],
+    },
+];
+//# sourceMappingURL=constants.js.map

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

@@ -0,0 +1,180 @@
+/**
+ * Repository handler functions
+ * Business logic for repository-related MCP tools
+ */
+import type { GetFileInput, ListExamplesInput, GetLatestUpdatesInput, GetVersionInfoInput, CheckBreakingChangesInput, GetMigrationGuideInput, GetFileAtVersionInput, CompareSyntaxInput, GetLatestSyntaxInput } from "./schemas.js";
+/**
+ * Resolve repository name alias to owner/repo
+ */
+export declare function resolveRepo(repoName?: string): {
+    owner: string;
+    repo: string;
+} | null;
+/**
+ * Retrieve a specific file from Midnight repositories
+ */
+export declare function getFile(input: GetFileInput): Promise<{
+    error: string;
+    suggestion: string;
+    repository?: undefined;
+    content?: undefined;
+    path?: undefined;
+    sha?: undefined;
+    size?: undefined;
+    url?: undefined;
+} | {
+    error: string;
+    repository: string;
+    suggestion: string;
+    content?: undefined;
+    path?: undefined;
+    sha?: undefined;
+    size?: undefined;
+    url?: undefined;
+} | {
+    content: string;
+    path: string;
+    repository: string;
+    sha: string;
+    size: number;
+    url: string;
+    error?: undefined;
+    suggestion?: undefined;
+}>;
+/**
+ * List available example contracts and DApps
+ */
+export declare function listExamples(input: ListExamplesInput): Promise<{
+    examples: {
+        name: string;
+        repository: string;
+        description: string;
+        complexity: "beginner" | "intermediate" | "advanced";
+        mainFile: string;
+        features: string[];
+        githubUrl: string;
+    }[];
+    totalCount: number;
+    categories: string[];
+}>;
+/**
+ * Retrieve recent changes across Midnight repositories
+ */
+export declare function getLatestUpdates(input: GetLatestUpdatesInput): Promise<{
+    summary: {
+        since: string;
+        totalCommits: number;
+        activeRepositories: number;
+        checkedRepositories: number;
+    };
+    updates: {
+        repository: string;
+        commitCount: number;
+        latestCommit: {
+            message: string;
+            date: string;
+            author: string;
+            url: string;
+        } | null;
+        recentCommits: {
+            message: string;
+            date: string;
+            sha: string;
+        }[];
+    }[];
+}>;
+/**
+ * Get version and release info for a repository
+ */
+export declare function getVersionInfo(input: GetVersionInfoInput): Promise<{
+    repository: string;
+    latestVersion: string;
+    latestStableVersion: string;
+    publishedAt: string | null;
+    releaseNotes: string | null;
+    recentReleases: {
+        version: string;
+        date: string;
+        isPrerelease: boolean;
+        url: string;
+    }[];
+    recentBreakingChanges: string[];
+    versionContext: string;
+}>;
+/**
+ * Check for breaking changes since a specific version
+ */
+export declare function checkBreakingChanges(input: CheckBreakingChangesInput): Promise<{
+    repository: string;
+    currentVersion: string;
+    latestVersion: string | null;
+    isOutdated: boolean;
+    versionsBehind: number;
+    hasBreakingChanges: boolean;
+    breakingChanges: string[];
+    recommendation: string;
+}>;
+/**
+ * Get migration guide between versions
+ */
+export declare function getMigrationGuide(input: GetMigrationGuideInput): Promise<{
+    repository: string;
+    from: string;
+    to: string;
+    summary: {
+        breakingChangesCount: number;
+        deprecationsCount: number;
+        newFeaturesCount: number;
+    };
+    breakingChanges: string[];
+    deprecations: string[];
+    newFeatures: string[];
+    migrationSteps: string[];
+    migrationDifficulty: string;
+}>;
+/**
+ * Get a file at a specific version - critical for version-accurate recommendations
+ */
+export declare function getFileAtVersion(input: GetFileAtVersionInput): Promise<{
+    repository: string;
+    path: string;
+    version: string;
+    content: string;
+    note: string;
+}>;
+/**
+ * Compare syntax between two versions - shows what changed
+ */
+export declare function compareSyntax(input: CompareSyntaxInput): Promise<{
+    repository: string;
+    path: string;
+    oldVersion: string;
+    newVersion: string;
+    hasDifferences: boolean;
+    oldContent: string | null;
+    newContent: string | null;
+    recommendation: string;
+}>;
+/**
+ * Get the latest syntax reference for Compact language
+ * This is the source of truth for writing valid, compilable contracts
+ */
+export declare function getLatestSyntax(input: GetLatestSyntaxInput): Promise<{
+    repository: string;
+    version: string;
+    warning: string;
+    syntaxFiles: never[];
+    examplePaths: string[];
+    note?: undefined;
+} | {
+    repository: string;
+    version: string;
+    syntaxFiles: {
+        path: string;
+        content: string;
+    }[];
+    note: string;
+    warning?: undefined;
+    examplePaths?: undefined;
+}>;
+//# sourceMappingURL=handlers.d.ts.map