@icogenie/mcp 0.1.1

package/CHANGELOG.md

@@ -0,0 +1,18 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+## [0.1.0] - 2025-01-28
+
+### Added
+- Initial release
+- `generate_icon` tool - Generate single icon preview (1 credit)
+- `regenerate_icon` tool - Regenerate variation with custom prompt (1 credit)
+- `check_credits` tool - Check credit balance (free)
+- `download_icon` tool - Download SVG/PNG package (5 credits single, 4/icon bundle)
+- `normalize_bundle` tool - Plan bundle icon list (free, rate-limited)
+- `generate_bundle` tool - Generate bundle from icon list (1 credit/icon)
+- Browser-based OAuth authentication (shared with @icogenie/cli)
+- Reference image support for style extraction
+- CI/CD support via `ICOGENIE_SESSION_TOKEN` environment variable
+- Stdio transport for Claude Desktop and Cursor integration

package/README.md

@@ -0,0 +1,209 @@
+# @icogenie/mcp
+
+MCP (Model Context Protocol) server for IcoGenie. Enables AI agents like Claude to generate production-ready SVG icons programmatically.
+
+## Installation
+
+```bash
+npm install -g @icogenie/mcp
+# or use directly with npx
+npx @icogenie/mcp
+```
+
+## Configuration
+
+### Claude Desktop
+
+Add to your Claude Desktop configuration (`~/Library/Application Support/Claude/claude_desktop_config.json` on macOS):
+
+```json
+{
+  "mcpServers": {
+    "icogenie": {
+      "command": "npx",
+      "args": ["-y", "@icogenie/mcp"]
+    }
+  }
+}
+```
+
+### Claude Code
+
+The server works automatically when installed globally or via npx.
+
+## Authentication
+
+On first use, the MCP server will:
+1. Open your browser for authentication
+2. Ask you to approve access
+3. Save the session token to `~/.icogenie/config.json`
+
+Subsequent uses are automatic - the token is shared with the [IcoGenie CLI](https://www.npmjs.com/package/@icogenie/cli).
+
+### CI/CD Environments
+
+Set `ICOGENIE_SESSION_TOKEN` environment variable to skip browser authentication:
+
+```bash
+export ICOGENIE_SESSION_TOKEN="your-session-token"
+```
+
+## Available Tools
+
+### generate_icon
+Generate a single icon preview from a text description.
+
+**Cost:** 1 credit
+
+```
+generate_icon({
+  prompt: "home icon",
+  style: "solid",       // or "outline"
+  variations: 1,        // 1, 2, or 4
+  referenceImagePath: "/path/to/reference.png"  // optional
+})
+```
+
+**Returns:** `{ generationId, preview, creditsUsed, creditsRemaining, metadata }`
+
+### regenerate_icon
+Regenerate a specific icon variation with a custom refinement prompt.
+
+**Cost:** 1 credit
+
+```
+regenerate_icon({
+  generationId: "abc123",  // or bundleId for bundles
+  index: 0,                // which variation (0-based)
+  prompt: "Make it more 3D"  // optional refinement
+})
+```
+
+### check_credits
+Check your current credit balance.
+
+**Cost:** Free
+
+```
+check_credits()
+```
+
+**Returns:** `{ credits, team, user }`
+
+### download_icon
+Download the final SVG + PNG package for an icon or bundle.
+
+**Cost:** 5 credits (single) or 4 credits/icon (bundle)
+
+```
+download_icon({
+  generationId: "abc123",  // or bundleId
+  outputPath: "./icons.zip"  // optional, returns base64 if omitted
+})
+```
+
+### normalize_bundle
+Plan an icon bundle by generating an AI-enhanced icon list from a description.
+
+**Cost:** Free (rate-limited)
+
+```
+normalize_bundle({
+  description: "food delivery app",
+  targetCount: 10,
+  style: "solid"
+})
+```
+
+**Returns:** `{ icons, bundleType, styleRecommendation, reasoning }`
+
+### generate_bundle
+Generate a bundle of icons from an icon list.
+
+**Cost:** 1 credit per icon
+
+```
+generate_bundle({
+  icons: [
+    { name: "home", description: "Home navigation icon" },
+    { name: "cart", description: "Shopping cart icon" }
+  ],
+  style: "solid"
+})
+```
+
+**Returns:** `{ bundleId, icons: [{ name, preview }], credits }`
+
+## Example Workflow
+
+1. **Check credits:**
+   ```
+   check_credits()
+   → { credits: 50, team: { name: "Personal" } }
+   ```
+
+2. **Generate a single icon:**
+   ```
+   generate_icon({ prompt: "notification bell icon", style: "outline" })
+   → { generationId: "abc123", preview: "...", creditsRemaining: 49 }
+   ```
+
+3. **Refine if needed:**
+   ```
+   regenerate_icon({ generationId: "abc123", index: 0, prompt: "Add a dot indicator" })
+   → { preview: "...", creditsRemaining: 48 }
+   ```
+
+4. **Download final package:**
+   ```
+   download_icon({ generationId: "abc123", outputPath: "./bell-icon.zip" })
+   → { savedTo: "./bell-icon.zip", creditsRemaining: 43 }
+   ```
+
+## Bundle Workflow
+
+1. **Plan the bundle (free):**
+   ```
+   normalize_bundle({ description: "e-commerce app icons", targetCount: 8 })
+   → { icons: [{ name: "cart", ... }, ...], styleRecommendation: "outline" }
+   ```
+
+2. **Review and generate:**
+   ```
+   generate_bundle({ icons: [...], style: "outline" })
+   → { bundleId: "xyz789", icons: [...], credits: { previewUsed: 8 } }
+   ```
+
+3. **Download bundle:**
+   ```
+   download_icon({ bundleId: "xyz789", outputPath: "./ecommerce-icons.zip" })
+   ```
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `ICOGENIE_API_URL` | API endpoint | `https://icogenie.com` |
+| `ICOGENIE_SESSION_TOKEN` | Session token (for CI/CD) | - |
+| `ICOGENIE_CONFIG_DIR` | Config directory | `~/.icogenie` |
+
+## Credit Pricing
+
+| Action | Cost |
+|--------|------|
+| Preview (single) | 1 credit |
+| Preview (bundle) | 1 credit/icon |
+| Download (single) | 5 credits |
+| Download (bundle) | 4 credits/icon |
+| Regenerate | 1 credit |
+
+Purchase credits at [icogenie.com](https://icogenie.com).
+
+## Related
+
+- [@icogenie/cli](https://www.npmjs.com/package/@icogenie/cli) - Command-line interface
+- [IcoGenie Web](https://icogenie.com) - Web application
+
+## License
+
+MIT

package/dist/index.d.ts

@@ -0,0 +1 @@
+#!/usr/bin/env node

package/dist/index.js

@@ -0,0 +1,519 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/server.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+
+// src/tools/generate.ts
+import { z } from "zod";
+
+// src/api/client.ts
+import { readFileSync, statSync } from "fs";
+import { extname } from "path";
+
+// src/auth/config.ts
+import Conf from "conf";
+import { homedir } from "os";
+import { join } from "path";
+import { mkdirSync, existsSync } from "fs";
+var configDir = process.env.ICOGENIE_CONFIG_DIR || join(homedir(), ".icogenie");
+if (!existsSync(configDir)) {
+  mkdirSync(configDir, { recursive: true });
+}
+var config = new Conf({
+  projectName: "icogenie",
+  cwd: configDir,
+  defaults: {
+    apiUrl: "https://icogenie.com"
+  }
+});
+function getApiUrl() {
+  return process.env.ICOGENIE_API_URL || config.get("apiUrl");
+}
+function getCredentials() {
+  const envToken = process.env.ICOGENIE_SESSION_TOKEN;
+  if (envToken) {
+    return {
+      sessionToken: envToken,
+      userId: "env-user",
+      userEmail: "env@icogenie.com",
+      teamId: "env-team",
+      teamName: "Environment",
+      createdAt: (/* @__PURE__ */ new Date()).toISOString()
+    };
+  }
+  return config.get("credentials");
+}
+function setCredentials(credentials) {
+  config.set("credentials", credentials);
+}
+function clearCredentials() {
+  config.delete("credentials");
+}
+
+// src/auth/flow.ts
+import open from "open";
+async function request(endpoint, body) {
+  const url = `${getApiUrl()}/api/cli${endpoint}`;
+  const response = await fetch(url, {
+    method: "POST",
+    headers: { "Content-Type": "application/json" },
+    body: JSON.stringify(body)
+  });
+  const data = await response.json();
+  if (!response.ok) {
+    throw new Error(data.error || data.message || "Request failed");
+  }
+  return data;
+}
+async function startAuth() {
+  return request("/auth/start", {});
+}
+async function pollAuth(pollToken) {
+  return request("/auth/poll", { pollToken });
+}
+async function authenticate() {
+  const { pollToken, loginUrl, expiresInSeconds } = await startAuth();
+  await open(loginUrl);
+  const pollInterval = 2e3;
+  const maxAttempts = Math.floor(expiresInSeconds * 1e3 / pollInterval);
+  let attempts = 0;
+  while (attempts < maxAttempts) {
+    await new Promise((resolve) => setTimeout(resolve, pollInterval));
+    attempts++;
+    const result = await pollAuth(pollToken);
+    if (result.status === "approved" && result.sessionToken && result.user && result.team) {
+      const credentials = {
+        sessionToken: result.sessionToken,
+        userId: result.user.id,
+        userEmail: result.user.email,
+        userName: result.user.name,
+        teamId: result.team.id,
+        teamName: result.team.name,
+        createdAt: (/* @__PURE__ */ new Date()).toISOString()
+      };
+      setCredentials(credentials);
+      return credentials;
+    }
+    if (result.status === "expired") {
+      throw new Error("Authentication request expired. Please try again.");
+    }
+  }
+  throw new Error("Authentication timed out. Please try again.");
+}
+
+// src/auth/middleware.ts
+var AuthError = class extends Error {
+  constructor(message, code) {
+    super(message);
+    this.code = code;
+    this.name = "AuthError";
+  }
+};
+async function ensureAuth() {
+  let credentials = getCredentials();
+  if (!credentials) {
+    try {
+      credentials = await authenticate();
+    } catch (error) {
+      throw new AuthError(
+        `Authentication required. Please approve access in your browser. Error: ${error instanceof Error ? error.message : "Unknown error"}`,
+        "AUTH_FAILED"
+      );
+    }
+  }
+  return credentials;
+}
+async function handleAuthError() {
+  clearCredentials();
+  try {
+    return await authenticate();
+  } catch (error) {
+    throw new AuthError(
+      "Session expired. Please approve access in your browser.",
+      "SESSION_EXPIRED"
+    );
+  }
+}
+
+// src/api/client.ts
+var ApiError = class extends Error {
+  constructor(message, statusCode, details) {
+    super(message);
+    this.statusCode = statusCode;
+    this.details = details;
+    this.name = "ApiError";
+  }
+};
+var SUPPORTED_IMAGE_FORMATS = [".png", ".jpg", ".jpeg", ".webp"];
+var MAX_IMAGE_SIZE = 5 * 1024 * 1024;
+function readReferenceImage(filePath) {
+  const ext = extname(filePath).toLowerCase();
+  if (!SUPPORTED_IMAGE_FORMATS.includes(ext)) {
+    throw new Error(`Unsupported image format: ${ext}. Supported: ${SUPPORTED_IMAGE_FORMATS.join(", ")}`);
+  }
+  const stats = statSync(filePath);
+  if (stats.size > MAX_IMAGE_SIZE) {
+    throw new Error(`Image too large: ${(stats.size / 1024 / 1024).toFixed(1)}MB. Max: 5MB`);
+  }
+  const buffer = readFileSync(filePath);
+  const mimeType = ext === ".png" ? "image/png" : ext === ".webp" ? "image/webp" : "image/jpeg";
+  return { data: buffer.toString("base64"), mimeType };
+}
+async function request2(endpoint, body, requireAuth = true) {
+  const url = `${getApiUrl()}/api/cli${endpoint}`;
+  const makeRequest = async (sessionToken) => {
+    const requestBody = sessionToken ? { ...body, sessionToken } : body;
+    const response = await fetch(url, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: JSON.stringify(requestBody)
+    });
+    const data = await response.json();
+    if (response.status === 401 && requireAuth) {
+      const newCreds = await handleAuthError();
+      return makeRequest(newCreds.sessionToken);
+    }
+    if (!response.ok) {
+      throw new ApiError(
+        data.error || data.message || "Request failed",
+        response.status,
+        data
+      );
+    }
+    return data;
+  };
+  if (requireAuth) {
+    const credentials = await ensureAuth();
+    return makeRequest(credentials.sessionToken);
+  }
+  return makeRequest();
+}
+async function generate(options) {
+  return request2("/generate", {
+    prompt: options.prompt,
+    variations: options.variations || 1,
+    style: options.style || "solid",
+    ...options.referenceImage && { referenceImage: options.referenceImage }
+  });
+}
+async function regenerate(options) {
+  return request2("/regenerate", {
+    generationId: options.generationId,
+    bundleId: options.bundleId,
+    index: options.index,
+    prompt: options.prompt
+  });
+}
+async function getCredits() {
+  return request2("/credits", {});
+}
+async function download(options) {
+  return request2("/download", {
+    generationId: options.generationId,
+    bundleId: options.bundleId
+  });
+}
+async function normalizeBundle(options) {
+  return request2("/normalize", {
+    description: options.description,
+    targetCount: options.targetCount,
+    style: options.style
+  });
+}
+async function generateBundle(options) {
+  return request2("/bundle", {
+    description: options.description,
+    targetCount: options.targetCount,
+    icons: options.icons,
+    style: options.style || "solid",
+    ...options.referenceImage && { referenceImage: options.referenceImage }
+  });
+}
+
+// src/tools/generate.ts
+var generateIconSchema = {
+  prompt: z.string().describe("Description of the icon to generate"),
+  style: z.enum(["solid", "outline"]).default("solid").describe("Icon style"),
+  variations: z.union([z.literal(1), z.literal(2), z.literal(4)]).default(1).describe("Number of variations (1, 2, or 4)"),
+  referenceImagePath: z.string().optional().describe("Local file path to reference image for style extraction"),
+  referenceImage: z.object({
+    data: z.string().describe("Base64-encoded image data"),
+    mimeType: z.enum(["image/png", "image/jpeg", "image/webp"])
+  }).optional().describe("Base64-encoded reference image")
+};
+async function generateIcon(args) {
+  let refImage;
+  if (args.referenceImagePath) {
+    refImage = readReferenceImage(args.referenceImagePath);
+  } else if (args.referenceImage) {
+    refImage = args.referenceImage;
+  }
+  const result = await generate({
+    prompt: args.prompt,
+    style: args.style || "solid",
+    variations: args.variations || 1,
+    referenceImage: refImage
+  });
+  return {
+    generationId: result.generationId,
+    preview: result.preview,
+    creditsUsed: result.creditsUsed,
+    creditsRemaining: result.creditsRemaining,
+    metadata: result.metadata
+  };
+}
+
+// src/tools/regenerate.ts
+import { z as z2 } from "zod";
+var regenerateIconSchema = {
+  generationId: z2.string().optional().describe("For single icon variations"),
+  bundleId: z2.string().optional().describe("For bundle icons"),
+  index: z2.number().describe("Which variation/icon to regenerate (0-based)"),
+  prompt: z2.string().optional().describe("Custom refinement prompt")
+};
+async function regenerateIcon(args) {
+  if (!args.generationId && !args.bundleId) {
+    throw new Error("Must provide either generationId or bundleId");
+  }
+  const result = await regenerate({
+    generationId: args.generationId,
+    bundleId: args.bundleId,
+    index: args.index,
+    prompt: args.prompt
+  });
+  return {
+    success: result.success,
+    preview: result.preview,
+    creditsUsed: result.creditsUsed,
+    creditsRemaining: result.creditsRemaining
+  };
+}
+
+// src/tools/credits.ts
+var checkCreditsSchema = {};
+async function checkCredits() {
+  const result = await getCredits();
+  return {
+    credits: result.credits,
+    team: result.team,
+    user: result.user
+  };
+}
+
+// src/tools/download.ts
+import { z as z3 } from "zod";
+import { writeFileSync } from "fs";
+var downloadIconSchema = {
+  generationId: z3.string().optional().describe("ID from generate_icon result (for single icons)"),
+  bundleId: z3.string().optional().describe("ID from generate_bundle result (for bundles)"),
+  outputPath: z3.string().optional().describe("Where to save the ZIP file")
+};
+async function downloadIcon(args) {
+  if (!args.generationId && !args.bundleId) {
+    throw new Error("Must provide either generationId or bundleId");
+  }
+  const result = await download({
+    generationId: args.generationId,
+    bundleId: args.bundleId
+  });
+  const response = {
+    success: result.success,
+    creditsUsed: result.creditsUsed,
+    creditsRemaining: result.creditsRemaining,
+    iconCount: result.iconCount
+  };
+  if (args.outputPath) {
+    const buffer = Buffer.from(result.bundle.data, "base64");
+    writeFileSync(args.outputPath, buffer);
+    response.savedTo = args.outputPath;
+  } else {
+    response.bundle = {
+      data: result.bundle.data,
+      filename: result.bundle.filename
+    };
+  }
+  return response;
+}
+
+// src/tools/normalize-bundle.ts
+import { z as z4 } from "zod";
+var normalizeBundleSchema = {
+  description: z4.string().describe("Description of the icon bundle to create"),
+  targetCount: z4.number().optional().describe("Target number of icons (2-20)"),
+  style: z4.enum(["solid", "outline"]).optional().describe("Preferred icon style")
+};
+async function normalizeBundleTool(args) {
+  const result = await normalizeBundle({
+    description: args.description,
+    targetCount: args.targetCount,
+    style: args.style
+  });
+  return {
+    icons: result.icons,
+    bundleType: result.bundleType,
+    suggestedCount: result.suggestedCount,
+    styleRecommendation: result.styleRecommendation,
+    reasoning: result.reasoning
+  };
+}
+
+// src/tools/generate-bundle.ts
+import { z as z5 } from "zod";
+var generateBundleSchema = {
+  icons: z5.array(
+    z5.object({
+      name: z5.string().regex(/^[a-z0-9-]+$/).describe("Icon name in kebab-case"),
+      description: z5.string().describe("Icon description")
+    })
+  ).optional().describe("Icon list from normalize_bundle or custom"),
+  description: z5.string().optional().describe("Alternative: describe the bundle to auto-generate icon list"),
+  targetCount: z5.number().optional().describe("Target icon count when using description"),
+  style: z5.enum(["solid", "outline"]).default("solid").describe("Icon style"),
+  referenceImagePath: z5.string().optional().describe("Local file path to reference image"),
+  referenceImage: z5.object({
+    data: z5.string(),
+    mimeType: z5.enum(["image/png", "image/jpeg", "image/webp"])
+  }).optional().describe("Base64-encoded reference image")
+};
+async function generateBundleTool(args) {
+  if (!args.icons && !args.description) {
+    throw new Error("Must provide either icons array or description");
+  }
+  let refImage;
+  if (args.referenceImagePath) {
+    refImage = readReferenceImage(args.referenceImagePath);
+  } else if (args.referenceImage) {
+    refImage = args.referenceImage;
+  }
+  const result = await generateBundle({
+    icons: args.icons,
+    description: args.description,
+    targetCount: args.targetCount,
+    style: args.style || "solid",
+    referenceImage: refImage
+  });
+  return {
+    bundleId: result.bundleId,
+    iconCount: result.iconCount,
+    icons: result.icons.map((icon) => ({
+      name: icon.name,
+      description: icon.description,
+      preview: icon.preview
+    })),
+    credits: result.credits,
+    nextStep: result.nextStep
+  };
+}
+
+// src/server.ts
+function createServer() {
+  const server = new McpServer({
+    name: "icogenie",
+    version: "0.1.0"
+  });
+  server.registerTool(
+    "generate_icon",
+    {
+      title: "Generate Icon",
+      description: "Generate an AI-powered icon preview from a text description. Costs 1 credit. Returns a generationId for download.",
+      inputSchema: generateIconSchema
+    },
+    async (args) => {
+      const result = await generateIcon(args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        structuredContent: result
+      };
+    }
+  );
+  server.registerTool(
+    "regenerate_icon",
+    {
+      title: "Regenerate Icon",
+      description: "Regenerate a specific icon variation with an optional custom prompt. Costs 1 credit. Use with generationId (single) or bundleId (bundle).",
+      inputSchema: regenerateIconSchema
+    },
+    async (args) => {
+      const result = await regenerateIcon(args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        structuredContent: result
+      };
+    }
+  );
+  server.registerTool(
+    "check_credits",
+    {
+      title: "Check Credits",
+      description: "Check the current credit balance and account information. Free to use.",
+      inputSchema: checkCreditsSchema
+    },
+    async () => {
+      const result = await checkCredits();
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        structuredContent: result
+      };
+    }
+  );
+  server.registerTool(
+    "download_icon",
+    {
+      title: "Download Icon",
+      description: "Download the final SVG + PNG package for an icon. Costs 5 credits (single) or 4 credits/icon (bundle). Provide outputPath to save to file.",
+      inputSchema: downloadIconSchema
+    },
+    async (args) => {
+      const result = await downloadIcon(args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        structuredContent: result
+      };
+    }
+  );
+  server.registerTool(
+    "normalize_bundle",
+    {
+      title: "Normalize Bundle",
+      description: "Plan an icon bundle by generating an AI-enhanced icon list from a description. Free but rate-limited. Review the list before generating.",
+      inputSchema: normalizeBundleSchema
+    },
+    async (args) => {
+      const result = await normalizeBundleTool(args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        structuredContent: result
+      };
+    }
+  );
+  server.registerTool(
+    "generate_bundle",
+    {
+      title: "Generate Bundle",
+      description: "Generate a bundle of icons from an icon list. Costs 1 credit per icon. Use normalize_bundle first to plan, or provide icons directly.",
+      inputSchema: generateBundleSchema
+    },
+    async (args) => {
+      const result = await generateBundleTool(args);
+      return {
+        content: [{ type: "text", text: JSON.stringify(result, null, 2) }],
+        structuredContent: result
+      };
+    }
+  );
+  return server;
+}
+
+// src/index.ts
+async function main() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@icogenie/mcp",
+  "version": "0.1.1",
+  "description": "MCP server for IcoGenie - Enable AI agents to generate icons programmatically",
+  "type": "module",
+  "bin": {
+    "icogenie-mcp": "dist/index.js"
+  },
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "files": [
+    "dist",
+    "README.md",
+    "CHANGELOG.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.0",
+    "conf": "^12.0.0",
+    "open": "^10.0.0",
+    "zod": "^3.23.0"
+  },
+  "devDependencies": {
+    "@types/node": "^20.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "@repo/typescript-config": "0.0.0"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "icon",
+    "svg",
+    "generator",
+    "ai",
+    "icogenie",
+    "claude",
+    "anthropic"
+  ],
+  "author": {
+    "name": "ICOGenie",
+    "url": "https://icogenie.com"
+  },
+  "license": "MIT",
+  "homepage": "https://icogenie.com",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/icogenie/icogenie-mcp.git"
+  },
+  "publishConfig": {
+    "access": "public",
+    "registry": "https://registry.npmjs.org/"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --target node18 --dts --clean",
+    "dev": "tsup src/index.ts --format esm --target node18 --watch",
+    "type-check": "tsc --noEmit",
+    "start": "node dist/index.js",
+    "version": "pnpm run build",
+    "postversion": "git push && git push --tags",
+    "release:patch": "npm version patch -m 'chore(icogenie-mcp): release v%s' --tag-version-prefix='mcp-v'",
+    "release:minor": "npm version minor -m 'chore(icogenie-mcp): release v%s' --tag-version-prefix='mcp-v'",
+    "release:major": "npm version major -m 'chore(icogenie-mcp): release v%s' --tag-version-prefix='mcp-v'"
+  }
+}