midnight-mcp 0.0.9 → 0.1.0

package/dist/tools/analyze.js

@@ -230,6 +230,111 @@ function getPrivacyConsiderations(circuit) {
     }
     return considerations;
 }
+// Output schemas for analysis tools
+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" },
+                },
+            },
+        },
+        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" },
+                },
+            },
+        },
+        witnesses: {
+            type: "array",
+            description: "Witness functions",
+            items: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    returnType: { type: "string" },
+                    purpose: { type: "string" },
+                },
+            },
+        },
+        securityFindings: {
+            type: "array",
+            description: "Security analysis findings",
+            items: {
+                type: "object",
+                properties: {
+                    severity: {
+                        type: "string",
+                        enum: ["info", "warning", "error"],
+                    },
+                    message: { type: "string" },
+                    suggestion: { type: "string" },
+                },
+            },
+        },
+        recommendations: {
+            type: "array",
+            items: { type: "string" },
+            description: "Recommendations for improvement",
+        },
+    },
+    required: ["summary", "circuits"],
+    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",
+        },
+        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: {
+                type: "object",
+                properties: {
+                    name: { type: "string" },
+                    type: { type: "string" },
+                    description: { type: "string" },
+                },
+            },
+        },
+        returnType: { type: "string" },
+    },
+    required: ["name", "plainEnglishExplanation"],
+    description: "Detailed circuit explanation with privacy analysis",
+};
 // Tool definitions for MCP
 export const analyzeTools = [
     {
@@ -249,6 +354,12 @@ export const analyzeTools = [
             },
             required: ["code"],
         },
+        outputSchema: analyzeContractOutputSchema,
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            title: "Analyze Compact Contract",
+        },
         handler: analyzeContract,
     },
     {
@@ -264,6 +375,12 @@ export const analyzeTools = [
             },
             required: ["circuitCode"],
         },
+        outputSchema: explainCircuitOutputSchema,
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            title: "Explain Circuit",
+        },
         handler: explainCircuit,
     },
 ];

package/dist/tools/generation.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Contract generation tool using sampling capability
+ *
+ * Enables AI-assisted generation and review of Compact smart contracts
+ */
+import type { ExtendedToolDefinition } from "../types/index.js";
+export declare const generationTools: ExtendedToolDefinition[];
+export declare const generationHandlers: Record<string, (args: any) => Promise<any>>;
+//# sourceMappingURL=generation.d.ts.map

package/dist/tools/generation.js

@@ -0,0 +1,282 @@
+/**
+ * Contract generation tool using sampling capability
+ *
+ * Enables AI-assisted generation and review of Compact smart contracts
+ */
+import { z } from "zod";
+import { generateContract, reviewContract, generateDocumentation, isSamplingAvailable, } from "../services/index.js";
+// Input schemas
+const generateContractSchema = z.object({
+    requirements: z
+        .string()
+        .describe("Natural language description of the contract requirements"),
+    contractType: z
+        .enum(["counter", "token", "voting", "custom"])
+        .optional()
+        .describe("Type of contract to generate"),
+    baseExample: z
+        .string()
+        .optional()
+        .describe("Example contract code to use as a base"),
+});
+const reviewContractSchema = z.object({
+    code: z.string().describe("Compact contract code to review"),
+});
+const documentContractSchema = z.object({
+    code: z.string().describe("Compact contract code to document"),
+    format: z
+        .enum(["markdown", "jsdoc"])
+        .optional()
+        .describe("Documentation format (default: markdown)"),
+});
+// Output schemas for structured responses
+const generateContractOutputSchema = {
+    type: "object",
+    properties: {
+        code: {
+            type: "string",
+            description: "Generated Compact contract code",
+        },
+        explanation: {
+            type: "string",
+            description: "Brief explanation of what the contract does",
+        },
+        warnings: {
+            type: "array",
+            items: { type: "string" },
+            description: "Any warnings or notes about the generated code",
+        },
+        samplingAvailable: {
+            type: "boolean",
+            description: "Whether sampling capability was available",
+        },
+    },
+    required: ["code", "explanation", "warnings", "samplingAvailable"],
+};
+const reviewContractOutputSchema = {
+    type: "object",
+    properties: {
+        summary: {
+            type: "string",
+            description: "Summary of the contract review",
+        },
+        issues: {
+            type: "array",
+            items: {
+                type: "object",
+                properties: {
+                    severity: {
+                        type: "string",
+                        enum: ["error", "warning", "info"],
+                    },
+                    line: { type: "number" },
+                    message: { type: "string" },
+                    suggestion: { type: "string" },
+                },
+            },
+            description: "List of issues found",
+        },
+        improvedCode: {
+            type: "string",
+            description: "Improved version of the contract if applicable",
+        },
+        samplingAvailable: {
+            type: "boolean",
+            description: "Whether sampling capability was available",
+        },
+    },
+    required: ["summary", "issues", "samplingAvailable"],
+};
+const documentContractOutputSchema = {
+    type: "object",
+    properties: {
+        documentation: {
+            type: "string",
+            description: "Generated documentation",
+        },
+        format: {
+            type: "string",
+            description: "Format of the documentation",
+        },
+        samplingAvailable: {
+            type: "boolean",
+            description: "Whether sampling capability was available",
+        },
+    },
+    required: ["documentation", "format", "samplingAvailable"],
+};
+// Handler functions
+async function handleGenerateContract(args) {
+    const result = await generateContract(args.requirements, {
+        contractType: args.contractType,
+        baseExample: args.baseExample,
+    });
+    return {
+        ...result,
+        samplingAvailable: isSamplingAvailable(),
+    };
+}
+async function handleReviewContract(args) {
+    const result = await reviewContract(args.code);
+    return {
+        ...result,
+        samplingAvailable: isSamplingAvailable(),
+    };
+}
+async function handleDocumentContract(args) {
+    const documentation = await generateDocumentation(args.code, args.format || "markdown");
+    return {
+        documentation,
+        format: args.format || "markdown",
+        samplingAvailable: isSamplingAvailable(),
+    };
+}
+// Tool definitions
+export const generationTools = [
+    {
+        name: "midnight-generate-contract",
+        description: `🔮 AI-POWERED CONTRACT GENERATION
+
+Generates Compact smart contracts from natural language requirements.
+Uses the client's LLM through MCP sampling to create contracts.
+
+REQUIREMENTS FORMAT:
+- Describe what the contract should do
+- Specify state variables needed
+- Define access control requirements
+- List the operations/circuits needed
+
+CONTRACT TYPES:
+• counter - Simple counter with increment/decrement
+• token - Token with transfers and balances
+• voting - Voting/governance mechanisms
+• custom - Free-form custom contract
+
+EXAMPLE USAGE:
+"Create a token contract with private balances, mint/burn capabilities for admin, and transfer functionality between users"
+
+⚠️ REQUIRES: Client with sampling capability (e.g., Claude Desktop)`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                requirements: {
+                    type: "string",
+                    description: "Natural language description of the contract requirements",
+                },
+                contractType: {
+                    type: "string",
+                    enum: ["counter", "token", "voting", "custom"],
+                    description: "Type of contract to generate",
+                },
+                baseExample: {
+                    type: "string",
+                    description: "Example contract code to use as a base",
+                },
+            },
+            required: ["requirements"],
+        },
+        outputSchema: generateContractOutputSchema,
+        annotations: {
+            title: "Generate Compact Contract",
+            readOnlyHint: false,
+            idempotentHint: false,
+            openWorldHint: true,
+            longRunningHint: true,
+        },
+        handler: handleGenerateContract,
+    },
+    {
+        name: "midnight-review-contract",
+        description: `🔍 AI-POWERED CONTRACT REVIEW
+
+Performs security review and analysis of Compact smart contracts.
+Uses the client's LLM to identify issues and suggest improvements.
+
+CHECKS PERFORMED:
+• Security vulnerabilities
+• Privacy concerns (shielded state handling)
+• Logic errors
+• Best practice violations
+• Performance issues
+
+OUTPUT INCLUDES:
+• Summary of contract quality
+• List of issues with severity levels
+• Suggested fixes for each issue
+• Improved code version if applicable
+
+⚠️ REQUIRES: Client with sampling capability (e.g., Claude Desktop)`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "Compact contract code to review",
+                },
+            },
+            required: ["code"],
+        },
+        outputSchema: reviewContractOutputSchema,
+        annotations: {
+            title: "Review Compact Contract",
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+            longRunningHint: true,
+        },
+        handler: handleReviewContract,
+    },
+    {
+        name: "midnight-document-contract",
+        description: `📝 AI-POWERED DOCUMENTATION GENERATION
+
+Generates comprehensive documentation for Compact smart contracts.
+Uses the client's LLM to create detailed, human-readable docs.
+
+FORMATS:
+• markdown - Full Markdown documentation with examples
+• jsdoc - JSDoc-style inline comments
+
+MARKDOWN INCLUDES:
+• Contract overview and purpose
+• State variables with privacy annotations
+• Circuit function documentation
+• Witness function documentation
+• Usage examples
+• Security considerations
+
+⚠️ REQUIRES: Client with sampling capability (e.g., Claude Desktop)`,
+        inputSchema: {
+            type: "object",
+            properties: {
+                code: {
+                    type: "string",
+                    description: "Compact contract code to document",
+                },
+                format: {
+                    type: "string",
+                    enum: ["markdown", "jsdoc"],
+                    description: "Documentation format (default: markdown)",
+                },
+            },
+            required: ["code"],
+        },
+        outputSchema: documentContractOutputSchema,
+        annotations: {
+            title: "Generate Contract Documentation",
+            readOnlyHint: true,
+            idempotentHint: true,
+            openWorldHint: true,
+            longRunningHint: true,
+        },
+        handler: handleDocumentContract,
+    },
+];
+// Export handler map
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+export const generationHandlers = {
+    "midnight-generate-contract": handleGenerateContract,
+    "midnight-review-contract": handleReviewContract,
+    "midnight-document-contract": handleDocumentContract,
+};
+//# sourceMappingURL=generation.js.map

package/dist/tools/health.d.ts

@@ -2,6 +2,7 @@
  * Health check and diagnostic tools for MCP server
  */
 import { z } from "zod";
+import type { ExtendedToolDefinition } from "../types/index.js";
 export declare const HealthCheckInputSchema: z.ZodObject<{
     detailed: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
@@ -63,29 +64,5 @@ export declare function getStatus(_input: GetStatusInput): Promise<{
         metadata: import("../utils/cache.js").CacheStats;
     };
 }>;
-export declare const healthTools: ({
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            detailed: {
-                type: string;
-                description: string;
-                default: boolean;
-            };
-        };
-    };
-    handler: typeof healthCheck;
-} | {
-    name: string;
-    description: string;
-    inputSchema: {
-        type: "object";
-        properties: {
-            detailed?: undefined;
-        };
-    };
-    handler: typeof getStatus;
-})[];
+export declare const healthTools: ExtendedToolDefinition[];
 //# sourceMappingURL=health.d.ts.map

package/dist/tools/health.js

@@ -61,6 +61,65 @@ export async function getStatus(_input) {
         },
     };
 }
+// Output schemas for health tools
+const healthCheckOutputSchema = {
+    type: "object",
+    properties: {
+        status: {
+            type: "string",
+            enum: ["healthy", "degraded", "unhealthy"],
+            description: "Overall health status",
+        },
+        version: { type: "string", description: "Server version" },
+        rateLimit: {
+            type: "object",
+            properties: {
+                remaining: { type: "number" },
+                limit: { type: "number" },
+                percentUsed: { type: "number" },
+                status: { type: "string" },
+            },
+        },
+        cacheStats: {
+            type: "object",
+            properties: {
+                search: { type: "object" },
+                file: { type: "object" },
+                metadata: { type: "object" },
+            },
+        },
+    },
+    required: ["status"],
+    description: "Server health status with optional detailed diagnostics",
+};
+const getStatusOutputSchema = {
+    type: "object",
+    properties: {
+        server: { type: "string", description: "Server name" },
+        status: { type: "string", description: "Running status" },
+        timestamp: { type: "string", description: "ISO timestamp" },
+        rateLimit: {
+            type: "object",
+            properties: {
+                remaining: { type: "number" },
+                limit: { type: "number" },
+                percentUsed: { type: "number" },
+                status: { type: "string" },
+                message: { type: "string" },
+            },
+        },
+        cache: {
+            type: "object",
+            properties: {
+                search: { type: "object" },
+                file: { type: "object" },
+                metadata: { type: "object" },
+            },
+        },
+    },
+    required: ["server", "status", "timestamp"],
+    description: "Current server status and statistics",
+};
 // Tool definitions for MCP server
 export const healthTools = [
     {
@@ -76,6 +135,12 @@ export const healthTools = [
                 },
             },
         },
+        outputSchema: healthCheckOutputSchema,
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            title: "Health Check",
+        },
         handler: healthCheck,
     },
     {
@@ -85,6 +150,12 @@ export const healthTools = [
             type: "object",
             properties: {},
         },
+        outputSchema: getStatusOutputSchema,
+        annotations: {
+            readOnlyHint: true,
+            idempotentHint: true,
+            title: "Get Server Status",
+        },
         handler: getStatus,
     },
 ];