midnight-mcp 0.1.40 → 0.2.1

package/dist/services/index.js

@@ -1,6 +0,0 @@
-/**
- * Services index
- * Export all service modules
- */
-export { isSamplingAvailable, registerSamplingCallback, requestCompletion, generateContract, reviewContract, generateDocumentation, } from "./sampling.js";
-//# sourceMappingURL=index.js.map

package/dist/services/sampling.d.ts

@@ -1,62 +0,0 @@
-/**
- * Sampling service for agentic workflows
- *
- * Enables the MCP server to request LLM completions from the client,
- * allowing for sophisticated multi-step workflows like:
- * - Auto-generating contracts from examples
- * - Code review with suggested fixes
- * - Documentation generation
- */
-import type { SamplingRequest, SamplingResponse, ModelPreferences } from "../types/index.js";
-type SamplingCallback = (request: SamplingRequest) => Promise<SamplingResponse>;
-/**
- * Check if sampling is available
- */
-export declare function isSamplingAvailable(): boolean;
-/**
- * Register the sampling callback from the client
- * This is called during server initialization when client supports sampling
- */
-export declare function registerSamplingCallback(callback: SamplingCallback): void;
-/**
- * Request a completion from the LLM via the client
- */
-export declare function requestCompletion(messages: {
-    role: "user" | "assistant";
-    content: string;
-}[], options?: {
-    systemPrompt?: string;
-    maxTokens?: number;
-    temperature?: number;
-    modelPreferences?: ModelPreferences;
-}): Promise<string>;
-/**
- * Generate a Compact contract based on requirements
- */
-export declare function generateContract(requirements: string, options?: {
-    baseExample?: string;
-    contractType?: "counter" | "token" | "voting" | "custom";
-}): Promise<{
-    code: string;
-    explanation: string;
-    warnings: string[];
-}>;
-/**
- * Review contract code and suggest improvements
- */
-export declare function reviewContract(code: string): Promise<{
-    summary: string;
-    issues: Array<{
-        severity: "error" | "warning" | "info";
-        line?: number;
-        message: string;
-        suggestion?: string;
-    }>;
-    improvedCode?: string;
-}>;
-/**
- * Generate documentation for a contract
- */
-export declare function generateDocumentation(code: string, format?: "markdown" | "jsdoc"): Promise<string>;
-export {};
-//# sourceMappingURL=sampling.d.ts.map

package/dist/services/sampling.js

@@ -1,277 +0,0 @@
-/**
- * Sampling service for agentic workflows
- *
- * Enables the MCP server to request LLM completions from the client,
- * allowing for sophisticated multi-step workflows like:
- * - Auto-generating contracts from examples
- * - Code review with suggested fixes
- * - Documentation generation
- */
-import { logger } from "../utils/index.js";
-// Store for the sampling callback
-let samplingCallback = null;
-/**
- * Check if sampling is available
- */
-export function isSamplingAvailable() {
-    return samplingCallback !== null;
-}
-/**
- * Register the sampling callback from the client
- * This is called during server initialization when client supports sampling
- */
-export function registerSamplingCallback(callback) {
-    samplingCallback = callback;
-    logger.info("Sampling capability registered");
-}
-/**
- * Request a completion from the LLM via the client
- */
-export async function requestCompletion(messages, options = {}) {
-    if (!samplingCallback) {
-        throw new Error("Sampling not available - client does not support this capability");
-    }
-    const request = {
-        messages: messages.map((m) => ({
-            role: m.role,
-            content: { type: "text", text: m.content },
-        })),
-        systemPrompt: options.systemPrompt,
-        maxTokens: options.maxTokens ?? 2048,
-        temperature: options.temperature ?? 0.7,
-        modelPreferences: options.modelPreferences ?? {
-            hints: [{ name: "claude-3-sonnet" }, { name: "gpt-4" }],
-            intelligencePriority: 0.8,
-            speedPriority: 0.5,
-        },
-    };
-    logger.debug("Requesting LLM completion", {
-        messageCount: messages.length,
-        maxTokens: request.maxTokens,
-    });
-    const response = await samplingCallback(request);
-    if (response.content.type !== "text") {
-        throw new Error("Unexpected response content type");
-    }
-    return response.content.text;
-}
-/**
- * Generate a Compact contract based on requirements
- */
-export async function generateContract(requirements, options = {}) {
-    if (!isSamplingAvailable()) {
-        return {
-            code: "",
-            explanation: "Sampling not available - this feature requires a client that supports the sampling capability (like Claude Desktop)",
-            warnings: ["Feature unavailable without sampling support"],
-        };
-    }
-    const systemPrompt = `You are an expert Compact smart contract developer for the Midnight blockchain.
-Your task is to generate secure, well-documented Compact contracts based on user requirements.
-
-Key Compact concepts:
-- \`ledger { }\` - Defines on-chain state (public and private)
-- \`@private\` - Marks state as private/shielded
-- \`export circuit\` - Public functions that generate ZK proofs
-- \`witness\` - Off-chain computation functions
-- \`assert()\` - Creates ZK constraints
-- \`Counter\`, \`Map<K,V>\`, \`Set<T>\` - Built-in collection types
-- \`Field\`, \`Boolean\`, \`Uint<N>\`, \`Bytes<N>\` - Primitive types
-
-Always include:
-1. Proper imports (include "std")
-2. Clear ledger state definitions
-3. Access control where appropriate
-4. Comprehensive inline comments
-
-Return ONLY the Compact code, no explanations.`;
-    const userPrompt = options.baseExample
-        ? `Based on this example contract:
-\`\`\`compact
-${options.baseExample}
-\`\`\`
-
-Generate a new contract with these requirements:
-${requirements}`
-        : `Generate a Compact smart contract with these requirements:
-${requirements}
-
-Contract type: ${options.contractType || "custom"}`;
-    try {
-        const code = await requestCompletion([{ role: "user", content: userPrompt }], {
-            systemPrompt,
-            maxTokens: 4096,
-            temperature: 0.3, // Lower temperature for code generation
-            modelPreferences: {
-                hints: [{ name: "claude-3-sonnet" }],
-                intelligencePriority: 0.9,
-                speedPriority: 0.3,
-            },
-        });
-        // Extract code from markdown if wrapped
-        const extractedCode = code.includes("```")
-            ? code
-                .replace(/```compact?\n?/g, "")
-                .replace(/```/g, "")
-                .trim()
-            : code.trim();
-        // Generate explanation
-        const explanation = await requestCompletion([
-            {
-                role: "user",
-                content: `Briefly explain what this Compact contract does (2-3 sentences):
-\`\`\`compact
-${extractedCode}
-\`\`\``,
-            },
-        ], {
-            systemPrompt: "You are a Compact contract documentation expert. Be concise.",
-            maxTokens: 256,
-            temperature: 0.5,
-        });
-        return {
-            code: extractedCode,
-            explanation: explanation.trim(),
-            warnings: [],
-        };
-    }
-    catch (error) {
-        logger.error("Contract generation failed", { error: String(error) });
-        return {
-            code: "",
-            explanation: `Contract generation failed: ${String(error)}`,
-            warnings: ["Generation failed - check logs for details"],
-        };
-    }
-}
-/**
- * Review contract code and suggest improvements
- */
-export async function reviewContract(code) {
-    if (!isSamplingAvailable()) {
-        return {
-            summary: "Code review requires sampling capability",
-            issues: [
-                {
-                    severity: "info",
-                    message: "This feature requires a client that supports the sampling capability",
-                },
-            ],
-        };
-    }
-    const systemPrompt = `You are a Compact smart contract security auditor.
-Review the provided contract for:
-1. Security vulnerabilities
-2. Privacy concerns (improper handling of shielded state)
-3. Logic errors
-4. Best practice violations
-5. Gas/performance issues
-
-Respond in JSON format:
-{
-  "summary": "Brief summary of the contract and overall quality",
-  "issues": [
-    {
-      "severity": "error|warning|info",
-      "line": optional_line_number,
-      "message": "Description of the issue",
-      "suggestion": "How to fix it"
-    }
-  ],
-  "improvedCode": "Full improved contract code if changes are needed"
-}`;
-    try {
-        const response = await requestCompletion([
-            {
-                role: "user",
-                content: `Review this Compact contract:\n\`\`\`compact\n${code}\n\`\`\``,
-            },
-        ], {
-            systemPrompt,
-            maxTokens: 4096,
-            temperature: 0.2,
-        });
-        // Parse JSON response with error handling
-        const jsonMatch = response.match(/\{[\s\S]*\}/);
-        if (jsonMatch) {
-            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,
-            issues: [],
-        };
-    }
-    catch (error) {
-        logger.error("Contract review failed", { error: String(error) });
-        return {
-            summary: `Review failed: ${String(error)}`,
-            issues: [
-                {
-                    severity: "error",
-                    message: "Review failed - check logs for details",
-                },
-            ],
-        };
-    }
-}
-/**
- * Generate documentation for a contract
- */
-export async function generateDocumentation(code, format = "markdown") {
-    if (!isSamplingAvailable()) {
-        return "Documentation generation requires sampling capability";
-    }
-    const systemPrompt = format === "markdown"
-        ? `Generate comprehensive Markdown documentation for this Compact contract.
-Include:
-- Overview and purpose
-- State variables (with privacy annotations)
-- Circuit functions with parameters and effects
-- Witness functions
-- Usage examples
-- Security considerations`
-        : `Generate JSDoc-style documentation comments for this Compact contract.
-Add documentation comments above each:
-- Ledger field
-- Circuit function
-- Witness function
-- Type definition`;
-    try {
-        return await requestCompletion([
-            {
-                role: "user",
-                content: `Generate ${format} documentation for:\n\`\`\`compact\n${code}\n\`\`\``,
-            },
-        ], {
-            systemPrompt,
-            maxTokens: 4096,
-            temperature: 0.5,
-        });
-    }
-    catch (error) {
-        logger.error("Documentation generation failed", { error: String(error) });
-        return `Documentation generation failed: ${String(error)}`;
-    }
-}
-//# sourceMappingURL=sampling.js.map

package/dist/tools/analyze.d.ts

@@ -1,106 +0,0 @@
-import { z } from "zod";
-import type { ExtendedToolDefinition } from "../types/index.js";
-export declare const AnalyzeContractInputSchema: z.ZodObject<{
-    code: z.ZodString;
-    checkSecurity: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
-}, "strip", z.ZodTypeAny, {
-    code: string;
-    checkSecurity: boolean;
-}, {
-    code: string;
-    checkSecurity?: boolean | undefined;
-}>;
-export declare const ExplainCircuitInputSchema: z.ZodObject<{
-    circuitCode: z.ZodString;
-}, "strip", z.ZodTypeAny, {
-    circuitCode: string;
-}, {
-    circuitCode: string;
-}>;
-export type AnalyzeContractInput = z.infer<typeof AnalyzeContractInputSchema>;
-export type ExplainCircuitInput = z.infer<typeof ExplainCircuitInputSchema>;
-interface SecurityFinding {
-    severity: "info" | "warning" | "error";
-    message: string;
-    line?: number;
-    suggestion?: string;
-}
-/**
- * Analyze a Compact smart contract for structure, patterns, and potential issues
- */
-export declare function analyzeContract(input: AnalyzeContractInput): Promise<{
-    summary: {
-        hasLedger: boolean;
-        hasCircuits: boolean;
-        hasWitnesses: boolean;
-        totalLines: number;
-        publicCircuits: number;
-        privateCircuits: number;
-        publicState: number;
-        privateState: number;
-    };
-    structure: {
-        imports: string[];
-        exports: string[];
-        ledger: {
-            name: string;
-            type: string | undefined;
-            isPrivate: boolean;
-        }[];
-        circuits: {
-            name: string;
-            isPublic: boolean;
-            parameters: {
-                name: string;
-                type: string;
-            }[] | undefined;
-            returnType: string | undefined;
-        }[];
-        witnesses: {
-            name: string;
-            parameters: {
-                name: string;
-                type: string;
-            }[] | undefined;
-            returnType: string | undefined;
-        }[];
-        types: {
-            name: string;
-            definition: string | undefined;
-        }[];
-    };
-    securityFindings: SecurityFinding[];
-    recommendations: (string | undefined)[];
-}>;
-/**
- * Explain what a specific circuit does in plain language
- */
-export declare function explainCircuit(input: ExplainCircuitInput): Promise<{
-    error: string;
-    suggestion: string;
-    circuitName?: undefined;
-    isPublic?: undefined;
-    parameters?: undefined;
-    returnType?: undefined;
-    explanation?: undefined;
-    operations?: undefined;
-    zkImplications?: undefined;
-    privacyConsiderations?: undefined;
-} | {
-    circuitName: string;
-    isPublic: boolean;
-    parameters: {
-        name: string;
-        type: string;
-    }[] | undefined;
-    returnType: string | undefined;
-    explanation: string;
-    operations: string[];
-    zkImplications: string[];
-    privacyConsiderations: string[];
-    error?: undefined;
-    suggestion?: undefined;
-}>;
-export declare const analyzeTools: ExtendedToolDefinition[];
-export {};
-//# sourceMappingURL=analyze.d.ts.map