@proofai/mcp-server 1.0.0

package/README.md

@@ -0,0 +1,73 @@
+# @proofai/mcp-server
+
+MCP Server for ProofAI — plug AI compliance into Claude Code.
+
+## Install
+
+```bash
+npm install -g @proofai/mcp-server
+```
+
+## Configure Claude Code
+
+Add to `~/.claude/claude_desktop_config.json`:
+
+```json
+{
+  "mcpServers": {
+    "proofai": {
+      "command": "proofai-mcp",
+      "env": {
+        "PROOFAI_API_KEY": "pk_live_xxx",
+        "PROOFAI_ANON_KEY": "your-supabase-anon-key"
+      }
+    }
+  }
+}
+```
+
+## Tools
+
+### `proofai_certify`
+Certify an AI decision with cryptographic proof. Full pipeline in one call.
+
+```
+> Use proofai_certify to certify my analysis of this contract
+```
+
+### `proofai_log`
+Log an AI decision that already happened (prompt + response you provide).
+
+```
+> Use proofai_log to record this decision with prompt "..." and response "..."
+```
+
+### `proofai_verify`
+Verify a bundle's integrity and blockchain anchoring.
+
+```
+> Use proofai_verify to check bundle bnd_8019b37a7f44_1774735436195
+```
+
+### `proofai_polygonscan`
+Get the Polygonscan URL for independent verification.
+
+```
+> Use proofai_polygonscan for tx 0xbbf92ceb6354a066...
+```
+
+### `proofai_monitor`
+Get AI compliance monitoring stats (EU AI Act Article 72).
+
+```
+> Use proofai_monitor to check compliance status
+```
+
+## Why MCP?
+
+Developers use Claude Code, not web dashboards. This MCP server brings AI compliance directly into the coding workflow:
+
+- Every AI decision can be certified without leaving the terminal
+- Verification is one tool call away
+- Monitoring happens alongside development
+- No context switching between coding and compliance

package/SKILL.md

@@ -0,0 +1,53 @@
+# proofai
+
+Cryptographic proof that AI thought before it answered. EU AI Act Article 12 compliant.
+
+## Tools
+
+### proofai_certify
+Certify an AI decision with cryptographic proof. Runs the full ProofAI pipeline: compress, execute AI, analyze cognitive graph, sign with Ed25519, bundle evidence, anchor to Polygon blockchain, and verify. Returns a blockchain-verified evidence bundle with Polygonscan URL.
+
+**When to use:** When you need tamper-evident proof of an AI decision for compliance, audit, or legal purposes.
+
+### proofai_log
+Log an AI decision that already happened. Provide the original prompt and AI response — ProofAI signs it with Ed25519, bundles the evidence, and anchors the hash to Polygon. No AI execution needed.
+
+**When to use:** When you want to retroactively certify an AI interaction that already occurred.
+
+### proofai_verify
+Verify an evidence bundle's integrity and blockchain anchoring. Checks data integrity, timestamp validity, ledger anchoring, and hash matching against EU AI Act requirements.
+
+**When to use:** When you need to confirm a bundle hasn't been tampered with.
+
+### proofai_polygonscan
+Get the Polygonscan verification URL for a Polygon transaction hash. Anyone can independently verify the proof without an account.
+
+**When to use:** When you need to share a verification link with a regulator, client, or auditor.
+
+### proofai_monitor
+Get post-market monitoring statistics for AI compliance (EU AI Act Article 72). Returns anomaly counts, risk distribution, human review stats, and overall compliance status for the last 30 days.
+
+**When to use:** When you need a compliance health check of your AI system.
+
+## Setup
+
+```json
+{
+  "mcpServers": {
+    "proofai": {
+      "command": "npx",
+      "args": ["-y", "@proofai/mcp-server"],
+      "env": {
+        "PROOFAI_API_KEY": "pk_live_xxx",
+        "PROOFAI_ANON_KEY": "your-supabase-anon-key"
+      }
+    }
+  }
+}
+```
+
+## Links
+
+- GitHub: https://github.com/proof-ai/proofai
+- npm SDK: https://www.npmjs.com/package/@proofai/sdk
+- Regulator Portal: https://proofai-ochre.vercel.app/regulator

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/index.js

@@ -0,0 +1,232 @@
+#!/usr/bin/env node
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const mcp_js_1 = require("@modelcontextprotocol/sdk/server/mcp.js");
+const stdio_js_1 = require("@modelcontextprotocol/sdk/server/stdio.js");
+const zod_1 = require("zod");
+const API_BASE = process.env.PROOFAI_API_URL || "https://apzgbajvwzykygrxxrwm.supabase.co/functions/v1";
+const API_KEY = process.env.PROOFAI_API_KEY || "";
+const ANON_KEY = process.env.PROOFAI_ANON_KEY || "";
+async function callAPI(path, body) {
+    const headers = { "Content-Type": "application/json" };
+    if (API_KEY.startsWith("pk_live_")) {
+        headers["x-api-key"] = API_KEY;
+    }
+    if (ANON_KEY) {
+        headers["Authorization"] = `Bearer ${ANON_KEY}`;
+    }
+    const res = await fetch(`${API_BASE}/${path}`, {
+        method: "POST",
+        headers,
+        body: JSON.stringify(body),
+    });
+    if (!res.ok) {
+        const text = await res.text();
+        throw new Error(`ProofAI API error ${res.status}: ${text}`);
+    }
+    return res.json();
+}
+const server = new mcp_js_1.McpServer({
+    name: "proofai",
+    version: "1.0.0",
+});
+// --- Tool: Log an AI decision (full pipeline) ---
+server.tool("proofai_certify", "Certify an AI decision with cryptographic proof. Runs the full ProofAI pipeline: compress → execute → analyze → sign → bundle → anchor → verify. Returns a blockchain-verified evidence bundle.", {
+    prompt: zod_1.z.string().describe("The AI prompt to certify"),
+    provider: zod_1.z.enum(["anthropic", "openai", "gemini"]).default("anthropic").describe("AI provider"),
+    temperature: zod_1.z.number().default(0.7).describe("Generation temperature"),
+    maxTokens: zod_1.z.number().default(1024).describe("Max output tokens"),
+}, async ({ prompt, provider, temperature, maxTokens }) => {
+    try {
+        // 1. Compress
+        const compressed = (await callAPI("compress", { prompt, options: { compressionLevel: "medium" } }));
+        // 2. Execute
+        const execution = (await callAPI("execute", {
+            promptRef: compressed.id,
+            options: { provider, modelId: "auto", temperature, maxTokens },
+        }));
+        // 3. Analyze
+        const analysis = (await callAPI("analyze", {
+            executionId: execution.id,
+            analysisText: execution.output,
+        }));
+        // 4. Sign
+        const signature = (await callAPI("sign", {
+            executionId: execution.id,
+            rawOutput: execution.output,
+            modelProvider: execution.metadata.provider,
+            modelId: execution.metadata.model,
+            modelVersion: "latest",
+            modelParameters: { temperature },
+            executionMetrics: { tokens: execution.metadata.tokens.total },
+            requesterInfo: { source: "mcp-server" },
+            timestamps: { request_received: new Date().toISOString() },
+        }));
+        // 5. Bundle
+        const bundle = (await callAPI("bundle", {
+            promptId: compressed.id,
+            executionId: execution.id,
+            analysisId: analysis.id,
+            signatureId: signature.signatureId,
+            cognitiveHash: analysis.cognitiveHash,
+            promptContent: prompt,
+            aiResponse: execution.output,
+        }));
+        // 6. Anchor
+        let anchor = {};
+        try {
+            anchor = (await callAPI("anchor", { bundleId: bundle.id, network: "polygon" }));
+        }
+        catch { /* anchor is best-effort */ }
+        // 7. Verify
+        const verification = (await callAPI("verify", { bundleId: bundle.id }));
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        status: "certified",
+                        bundleId: bundle.id,
+                        bundleHash: bundle.bundleHash,
+                        verified: verification.verified,
+                        explorerUrl: anchor.explorerUrl || null,
+                        transactionHash: anchor.transactionHash || null,
+                        provider: execution.metadata.provider,
+                        model: execution.metadata.model,
+                        tokens: execution.metadata.tokens.total,
+                        cognitiveNodes: analysis.metrics.nodeCount,
+                        consistencyScore: analysis.metrics.consistencyScore,
+                        aiResponse: execution.output.substring(0, 500) + (execution.output.length > 500 ? "..." : ""),
+                    }, null, 2),
+                },
+            ],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Error: ${err.message}` }],
+            isError: true,
+        };
+    }
+});
+// --- Tool: Log a decision (just record, don't execute AI) ---
+server.tool("proofai_log", "Log an AI decision that already happened. Creates an evidence bundle with the prompt and response you provide, signs it with Ed25519, and anchors to Polygon.", {
+    prompt: zod_1.z.string().describe("The original prompt"),
+    response: zod_1.z.string().describe("The AI response to log"),
+    provider: zod_1.z.string().default("unknown").describe("Which AI provider generated the response"),
+    model: zod_1.z.string().default("unknown").describe("Which model was used"),
+}, async ({ prompt, response, provider, model }) => {
+    try {
+        // Compress
+        const compressed = (await callAPI("compress", { prompt, options: {} }));
+        // Analyze
+        const analysis = (await callAPI("analyze", {
+            executionId: `ext_${Date.now()}`,
+            analysisText: response,
+        }));
+        // Sign
+        const signature = (await callAPI("sign", {
+            executionId: `ext_${Date.now()}`,
+            rawOutput: response,
+            modelProvider: provider,
+            modelId: model,
+            modelVersion: "external",
+            modelParameters: {},
+            executionMetrics: {},
+            requesterInfo: { source: "mcp-server-log" },
+            timestamps: { logged_at: new Date().toISOString() },
+        }));
+        // Bundle
+        const bundle = (await callAPI("bundle", {
+            promptId: compressed.id,
+            executionId: `ext_${Date.now()}`,
+            analysisId: analysis.id,
+            signatureId: signature.signatureId,
+            cognitiveHash: analysis.cognitiveHash,
+            promptContent: prompt,
+            aiResponse: response,
+            provider,
+            model,
+        }));
+        // Anchor
+        let explorerUrl = null;
+        try {
+            const anchor = (await callAPI("anchor", { bundleId: bundle.id, network: "polygon" }));
+            explorerUrl = anchor.explorerUrl;
+        }
+        catch { /* best-effort */ }
+        return {
+            content: [{
+                    type: "text",
+                    text: `Logged and certified.\n\nBundle ID: ${bundle.id}\nBundle Hash: ${bundle.bundleHash}\nPolygonscan: ${explorerUrl || "pending"}\n\nThis decision is now tamper-evident and blockchain-anchored.`,
+                }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Error: ${err.message}` }],
+            isError: true,
+        };
+    }
+});
+// --- Tool: Verify a bundle ---
+server.tool("proofai_verify", "Verify an evidence bundle's integrity and blockchain anchoring. Returns compliance checks against EU AI Act articles.", {
+    bundleId: zod_1.z.string().describe("The bundle ID to verify (e.g., bnd_xxx)"),
+}, async ({ bundleId }) => {
+    try {
+        const result = (await callAPI("verify", { bundleId }));
+        const checksText = Object.entries(result.checks)
+            .map(([k, v]) => `  ${v ? "✅" : "❌"} ${k}`)
+            .join("\n");
+        return {
+            content: [{
+                    type: "text",
+                    text: `Bundle: ${result.bundleId}\nVerified: ${result.verified ? "✅ YES" : "❌ NO"}\n\nChecks:\n${checksText}${result.ledgerInfo
+                        ? `\n\nBlockchain:\n  Network: ${result.ledgerInfo.network}\n  Block: #${result.ledgerInfo.blockNumber}\n  Tx: ${result.ledgerInfo.transactionHash}`
+                        : ""}`,
+                }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Error: ${err.message}` }],
+            isError: true,
+        };
+    }
+});
+// --- Tool: Get Polygonscan link ---
+server.tool("proofai_polygonscan", "Get the Polygonscan verification URL for a transaction hash. Anyone can verify the proof independently.", {
+    txHash: zod_1.z.string().describe("The Polygon transaction hash (0x...)"),
+}, async ({ txHash }) => {
+    const url = `https://amoy.polygonscan.com/tx/${txHash}`;
+    return {
+        content: [{
+                type: "text",
+                text: `Polygonscan verification URL:\n${url}\n\nAnyone can verify this proof — no account, no login, no middleman. Just math.`,
+            }],
+    };
+});
+// --- Tool: Get monitoring stats ---
+server.tool("proofai_monitor", "Get post-market monitoring statistics for AI compliance (EU AI Act Article 72). Shows anomalies, risk distribution, and compliance status.", {}, async () => {
+    try {
+        const stats = await callAPI("monitor", {});
+        return {
+            content: [{
+                    type: "text",
+                    text: JSON.stringify(stats, null, 2),
+                }],
+        };
+    }
+    catch (err) {
+        return {
+            content: [{ type: "text", text: `Error: ${err.message}` }],
+            isError: true,
+        };
+    }
+});
+// Start server
+async function main() {
+    const transport = new stdio_js_1.StdioServerTransport();
+    await server.connect(transport);
+}
+main().catch(console.error);

package/package.json

@@ -0,0 +1,23 @@
+{
+  "name": "@proofai/mcp-server",
+  "version": "1.0.0",
+  "description": "ProofAI MCP Server — AI compliance tools for Claude Code",
+  "main": "dist/index.js",
+  "bin": {
+    "proofai-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsc",
+    "start": "node dist/index.js"
+  },
+  "author": "HIRAM",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.0.0",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^22.0.0",
+    "typescript": "^5.8.0"
+  }
+}

package/src/index.ts

@@ -0,0 +1,282 @@
+#!/usr/bin/env node
+
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+
+const API_BASE = process.env.PROOFAI_API_URL || "https://apzgbajvwzykygrxxrwm.supabase.co/functions/v1";
+const API_KEY = process.env.PROOFAI_API_KEY || "";
+const ANON_KEY = process.env.PROOFAI_ANON_KEY || "";
+
+async function callAPI(path: string, body: Record<string, unknown>): Promise<unknown> {
+  const headers: Record<string, string> = { "Content-Type": "application/json" };
+  if (API_KEY.startsWith("pk_live_")) {
+    headers["x-api-key"] = API_KEY;
+  }
+  if (ANON_KEY) {
+    headers["Authorization"] = `Bearer ${ANON_KEY}`;
+  }
+
+  const res = await fetch(`${API_BASE}/${path}`, {
+    method: "POST",
+    headers,
+    body: JSON.stringify(body),
+  });
+  if (!res.ok) {
+    const text = await res.text();
+    throw new Error(`ProofAI API error ${res.status}: ${text}`);
+  }
+  return res.json();
+}
+
+const server = new McpServer({
+  name: "proofai",
+  version: "1.0.0",
+});
+
+// --- Tool: Log an AI decision (full pipeline) ---
+server.tool(
+  "proofai_certify",
+  "Certify an AI decision with cryptographic proof. Runs the full ProofAI pipeline: compress → execute → analyze → sign → bundle → anchor → verify. Returns a blockchain-verified evidence bundle.",
+  {
+    prompt: z.string().describe("The AI prompt to certify"),
+    provider: z.enum(["anthropic", "openai", "gemini"]).default("anthropic").describe("AI provider"),
+    temperature: z.number().default(0.7).describe("Generation temperature"),
+    maxTokens: z.number().default(1024).describe("Max output tokens"),
+  },
+  async ({ prompt, provider, temperature, maxTokens }) => {
+    try {
+      // 1. Compress
+      const compressed = (await callAPI("compress", { prompt, options: { compressionLevel: "medium" } })) as { id: string; compressedDsl: string };
+
+      // 2. Execute
+      const execution = (await callAPI("execute", {
+        promptRef: compressed.id,
+        options: { provider, modelId: "auto", temperature, maxTokens },
+      })) as { id: string; output: string; metadata: { provider: string; model: string; tokens: { total: number } } };
+
+      // 3. Analyze
+      const analysis = (await callAPI("analyze", {
+        executionId: execution.id,
+        analysisText: execution.output,
+      })) as { id: string; cognitiveHash: string; metrics: { nodeCount: number; consistencyScore: number } };
+
+      // 4. Sign
+      const signature = (await callAPI("sign", {
+        executionId: execution.id,
+        rawOutput: execution.output,
+        modelProvider: execution.metadata.provider,
+        modelId: execution.metadata.model,
+        modelVersion: "latest",
+        modelParameters: { temperature },
+        executionMetrics: { tokens: execution.metadata.tokens.total },
+        requesterInfo: { source: "mcp-server" },
+        timestamps: { request_received: new Date().toISOString() },
+      })) as { signatureId: string };
+
+      // 5. Bundle
+      const bundle = (await callAPI("bundle", {
+        promptId: compressed.id,
+        executionId: execution.id,
+        analysisId: analysis.id,
+        signatureId: signature.signatureId,
+        cognitiveHash: analysis.cognitiveHash,
+        promptContent: prompt,
+        aiResponse: execution.output,
+      })) as { id: string; bundleHash: string };
+
+      // 6. Anchor
+      let anchor: { transactionHash?: string; explorerUrl?: string; status?: string } = {};
+      try {
+        anchor = (await callAPI("anchor", { bundleId: bundle.id, network: "polygon" })) as typeof anchor;
+      } catch { /* anchor is best-effort */ }
+
+      // 7. Verify
+      const verification = (await callAPI("verify", { bundleId: bundle.id })) as { verified: boolean };
+
+      return {
+        content: [
+          {
+            type: "text" as const,
+            text: JSON.stringify({
+              status: "certified",
+              bundleId: bundle.id,
+              bundleHash: bundle.bundleHash,
+              verified: verification.verified,
+              explorerUrl: anchor.explorerUrl || null,
+              transactionHash: anchor.transactionHash || null,
+              provider: execution.metadata.provider,
+              model: execution.metadata.model,
+              tokens: execution.metadata.tokens.total,
+              cognitiveNodes: analysis.metrics.nodeCount,
+              consistencyScore: analysis.metrics.consistencyScore,
+              aiResponse: execution.output.substring(0, 500) + (execution.output.length > 500 ? "..." : ""),
+            }, null, 2),
+          },
+        ],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text" as const, text: `Error: ${(err as Error).message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// --- Tool: Log a decision (just record, don't execute AI) ---
+server.tool(
+  "proofai_log",
+  "Log an AI decision that already happened. Creates an evidence bundle with the prompt and response you provide, signs it with Ed25519, and anchors to Polygon.",
+  {
+    prompt: z.string().describe("The original prompt"),
+    response: z.string().describe("The AI response to log"),
+    provider: z.string().default("unknown").describe("Which AI provider generated the response"),
+    model: z.string().default("unknown").describe("Which model was used"),
+  },
+  async ({ prompt, response, provider, model }) => {
+    try {
+      // Compress
+      const compressed = (await callAPI("compress", { prompt, options: {} })) as { id: string };
+
+      // Analyze
+      const analysis = (await callAPI("analyze", {
+        executionId: `ext_${Date.now()}`,
+        analysisText: response,
+      })) as { id: string; cognitiveHash: string };
+
+      // Sign
+      const signature = (await callAPI("sign", {
+        executionId: `ext_${Date.now()}`,
+        rawOutput: response,
+        modelProvider: provider,
+        modelId: model,
+        modelVersion: "external",
+        modelParameters: {},
+        executionMetrics: {},
+        requesterInfo: { source: "mcp-server-log" },
+        timestamps: { logged_at: new Date().toISOString() },
+      })) as { signatureId: string };
+
+      // Bundle
+      const bundle = (await callAPI("bundle", {
+        promptId: compressed.id,
+        executionId: `ext_${Date.now()}`,
+        analysisId: analysis.id,
+        signatureId: signature.signatureId,
+        cognitiveHash: analysis.cognitiveHash,
+        promptContent: prompt,
+        aiResponse: response,
+        provider,
+        model,
+      })) as { id: string; bundleHash: string };
+
+      // Anchor
+      let explorerUrl: string | null = null;
+      try {
+        const anchor = (await callAPI("anchor", { bundleId: bundle.id, network: "polygon" })) as { explorerUrl: string };
+        explorerUrl = anchor.explorerUrl;
+      } catch { /* best-effort */ }
+
+      return {
+        content: [{
+          type: "text" as const,
+          text: `Logged and certified.\n\nBundle ID: ${bundle.id}\nBundle Hash: ${bundle.bundleHash}\nPolygonscan: ${explorerUrl || "pending"}\n\nThis decision is now tamper-evident and blockchain-anchored.`,
+        }],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text" as const, text: `Error: ${(err as Error).message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// --- Tool: Verify a bundle ---
+server.tool(
+  "proofai_verify",
+  "Verify an evidence bundle's integrity and blockchain anchoring. Returns compliance checks against EU AI Act articles.",
+  {
+    bundleId: z.string().describe("The bundle ID to verify (e.g., bnd_xxx)"),
+  },
+  async ({ bundleId }) => {
+    try {
+      const result = (await callAPI("verify", { bundleId })) as {
+        bundleId: string;
+        verified: boolean;
+        checks: Record<string, boolean>;
+        ledgerInfo?: { transactionHash: string; blockNumber: number; network: string };
+      };
+
+      const checksText = Object.entries(result.checks)
+        .map(([k, v]) => `  ${v ? "✅" : "❌"} ${k}`)
+        .join("\n");
+
+      return {
+        content: [{
+          type: "text" as const,
+          text: `Bundle: ${result.bundleId}\nVerified: ${result.verified ? "✅ YES" : "❌ NO"}\n\nChecks:\n${checksText}${
+            result.ledgerInfo
+              ? `\n\nBlockchain:\n  Network: ${result.ledgerInfo.network}\n  Block: #${result.ledgerInfo.blockNumber}\n  Tx: ${result.ledgerInfo.transactionHash}`
+              : ""
+          }`,
+        }],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text" as const, text: `Error: ${(err as Error).message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// --- Tool: Get Polygonscan link ---
+server.tool(
+  "proofai_polygonscan",
+  "Get the Polygonscan verification URL for a transaction hash. Anyone can verify the proof independently.",
+  {
+    txHash: z.string().describe("The Polygon transaction hash (0x...)"),
+  },
+  async ({ txHash }) => {
+    const url = `https://amoy.polygonscan.com/tx/${txHash}`;
+    return {
+      content: [{
+        type: "text" as const,
+        text: `Polygonscan verification URL:\n${url}\n\nAnyone can verify this proof — no account, no login, no middleman. Just math.`,
+      }],
+    };
+  }
+);
+
+// --- Tool: Get monitoring stats ---
+server.tool(
+  "proofai_monitor",
+  "Get post-market monitoring statistics for AI compliance (EU AI Act Article 72). Shows anomalies, risk distribution, and compliance status.",
+  {},
+  async () => {
+    try {
+      const stats = await callAPI("monitor", {});
+      return {
+        content: [{
+          type: "text" as const,
+          text: JSON.stringify(stats, null, 2),
+        }],
+      };
+    } catch (err) {
+      return {
+        content: [{ type: "text" as const, text: `Error: ${(err as Error).message}` }],
+        isError: true,
+      };
+    }
+  }
+);
+
+// Start server
+async function main() {
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+
+main().catch(console.error);

package/tsconfig.json

@@ -0,0 +1,14 @@
+{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "NodeNext",
+    "moduleResolution": "NodeNext",
+    "skipLibCheck": true,
+    "declaration": true,
+    "strict": true,
+    "esModuleInterop": true,
+    "outDir": "dist",
+    "rootDir": "src"
+  },
+  "include": ["src"]
+}