@caik.dev/mcp 0.1.0

package/README.md

@@ -0,0 +1,110 @@
+# @caik.dev/mcp
+
+MCP (Model Context Protocol) server for the [CAIK](https://caik.dev) AI artifact registry. Enables Claude Code, Cursor, Windsurf, Codex, and other MCP-capable agents to search, install, and contribute to the collective knowledge base.
+
+## Quick Start
+
+Add to your agent's MCP configuration:
+
+```json
+{
+  "mcpServers": {
+    "caik": {
+      "command": "npx",
+      "args": ["-y", "caik-mcp-server"]
+    }
+  }
+}
+```
+
+**Claude Code** (`~/.claude/settings.json`):
+
+```json
+{
+  "mcpServers": {
+    "caik": {
+      "command": "npx",
+      "args": ["-y", "caik-mcp-server"]
+    }
+  }
+}
+```
+
+## Authentication
+
+Some tools require authentication. Set up via the CLI:
+
+```bash
+npx @caik.dev/cli init
+```
+
+Or set the environment variable directly:
+
+```bash
+export CAIK_API_KEY=caik_...
+```
+
+The server reads credentials from `~/.caik/config.json` (written by `caik init`) or the `CAIK_API_KEY` / `CAIK_API_URL` environment variables.
+
+## Tools
+
+### Discovery
+
+| Tool | Description | Auth |
+|------|-------------|------|
+| `search` | Search for AI agent skills, MCP servers, prompts, tools, and stacks | No |
+| `get_artifact` | Get full details for an artifact by slug | No |
+| `get_family` | Get all variants of an artifact family, ranked by platform relevance | No |
+| `resolve_stack` | Resolve a stack into an ordered install sequence | No |
+
+### Account & Stats
+
+| Tool | Description | Auth |
+|------|-------------|------|
+| `get_account` | Get your account info, karma, and contribution level | Yes |
+| `get_stats` | Get platform-wide statistics | No |
+| `get_updates` | Check for available updates for an installation | Yes |
+
+### Contribution
+
+| Tool | Description | Auth |
+|------|-------------|------|
+| `report_outcome` | Report success/failure telemetry for an artifact | Yes |
+| `submit_review` | Upvote or downvote an artifact | Yes |
+
+### Bounties
+
+| Tool | Description | Auth |
+|------|-------------|------|
+| `list_bounties` | List community bounties for requested artifacts | No |
+| `claim_bounty` | Claim a bounty with your published artifact | Yes |
+
+### Publishing
+
+| Tool | Description | Auth |
+|------|-------------|------|
+| `submit_artifact` | Publish a new artifact to the registry | Yes |
+| `list_my_artifacts` | List your published artifacts | Yes |
+| `list_my_submissions` | Get submission pipeline summary | Yes |
+
+## Resources
+
+- `caik://artifact/{slug}` — Artifact detail as JSON
+- `caik://stack/{slug}` — Resolved stack as JSON
+
+## Prompt Templates
+
+- `discover` — Find tools and skills for your platform
+- `setup` — Set up a complete agent stack for a use case
+- `contribute` — Publish a new or forked artifact
+
+## Environment Variables
+
+| Variable | Description | Default |
+|----------|-------------|---------|
+| `CAIK_API_KEY` | API key for authenticated requests | Read from `~/.caik/config.json` |
+| `CAIK_API_URL` | API base URL | `https://caik.dev` |
+
+## License
+
+MIT

package/dist/index.js

@@ -0,0 +1,634 @@
+#!/usr/bin/env node
+
+// src/index.ts
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+
+// src/api.ts
+import { McpError, ErrorCode } from "@modelcontextprotocol/sdk/types.js";
+var CaikApiClient = class {
+  baseUrl;
+  apiKey;
+  constructor(config) {
+    this.baseUrl = config.apiUrl.replace(/\/+$/, "");
+    this.apiKey = config.apiKey;
+  }
+  hasApiKey() {
+    return !!this.apiKey;
+  }
+  requireAuth() {
+    if (!this.apiKey) {
+      throw new McpError(
+        ErrorCode.InvalidRequest,
+        "No API key configured. Run 'caik init' to set up authentication, or set CAIK_API_KEY environment variable."
+      );
+    }
+  }
+  async get(path, params) {
+    const url = new URL(`${this.baseUrl}/api/v1${path}`);
+    if (params) {
+      for (const [key, value] of Object.entries(params)) {
+        if (value === void 0) continue;
+        if (Array.isArray(value)) {
+          for (const v of value) url.searchParams.append(key, v);
+        } else {
+          url.searchParams.set(key, String(value));
+        }
+      }
+    }
+    return this.request(url.toString(), { method: "GET" });
+  }
+  async post(path, body) {
+    return this.request(`${this.baseUrl}/api/v1${path}`, {
+      method: "POST",
+      headers: { "Content-Type": "application/json" },
+      body: body !== void 0 ? JSON.stringify(body) : void 0
+    });
+  }
+  async request(url, init) {
+    const headers = {
+      ...init.headers
+    };
+    if (this.apiKey) {
+      headers["Authorization"] = `Bearer ${this.apiKey}`;
+    }
+    let response;
+    try {
+      response = await fetch(url, { ...init, headers });
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      throw new McpError(
+        ErrorCode.InternalError,
+        `Could not connect to the CAIK API: ${msg}. Check CAIK_API_URL or ensure the server is running.`
+      );
+    }
+    if (!response.ok) {
+      return this.handleHttpError(response);
+    }
+    if (response.status === 204) {
+      return void 0;
+    }
+    return response.json();
+  }
+  async handleHttpError(response) {
+    let body;
+    try {
+      body = await response.json();
+    } catch {
+      body = await response.text().catch(() => null);
+    }
+    const message = typeof body === "object" && body !== null && "message" in body ? String(body.message) : `Request failed with status ${response.status}`;
+    switch (response.status) {
+      case 401:
+        throw new McpError(
+          ErrorCode.InvalidRequest,
+          `Authentication failed: ${message}. Run 'caik init' to set up authentication.`
+        );
+      case 403:
+        throw new McpError(
+          ErrorCode.InvalidRequest,
+          `Insufficient permissions: ${message}. Your account tier may not allow this action.`
+        );
+      case 404:
+        throw new McpError(
+          ErrorCode.InvalidRequest,
+          `Not found: ${message}. Try using the 'search' tool to find the correct artifact.`
+        );
+      case 400:
+        throw new McpError(
+          ErrorCode.InvalidParams,
+          `Invalid request: ${message}. Check your input parameters and try again.`
+        );
+      case 429:
+        throw new McpError(
+          ErrorCode.InternalError,
+          "Rate limited. Please wait a moment and try again (limit: 120 requests/min)."
+        );
+      default:
+        throw new McpError(
+          ErrorCode.InternalError,
+          `Server error (${response.status}): ${message}. The CAIK API may be temporarily unavailable.`
+        );
+    }
+  }
+};
+
+// src/config.ts
+import { readFileSync, existsSync } from "fs";
+import { join } from "path";
+import { homedir } from "os";
+var DEFAULT_API_URL = "https://caik.dev";
+function getConfigPath() {
+  return join(homedir(), ".caik", "config.json");
+}
+function readConfig() {
+  const path = getConfigPath();
+  if (!existsSync(path)) {
+    return { apiUrl: DEFAULT_API_URL };
+  }
+  try {
+    const raw = readFileSync(path, "utf-8");
+    const parsed = JSON.parse(raw);
+    return { apiUrl: DEFAULT_API_URL, ...parsed };
+  } catch {
+    return { apiUrl: DEFAULT_API_URL };
+  }
+}
+function resolveConfig() {
+  const config = readConfig();
+  return {
+    apiUrl: process.env.CAIK_API_URL ?? config.apiUrl ?? DEFAULT_API_URL,
+    apiKey: process.env.CAIK_API_KEY ?? config.apiKey
+  };
+}
+
+// src/tools/discovery.ts
+import { z } from "zod";
+function registerDiscoveryTools(server, api) {
+  server.tool(
+    "search",
+    "Search the CAIK collective knowledge base for AI agent skills, MCP servers, prompts, tools, libraries, and stacks. Use this to discover artifacts by keyword, platform, or tag. Returns a ranked list with quality scores and install counts.",
+    {
+      query: z.string().describe("Search query (e.g., 'github code review', 'database MCP server')"),
+      platform: z.string().optional().describe("Filter by platform: 'claude-code', 'cursor', 'windsurf', 'codex', 'generic'"),
+      tags: z.array(z.string()).optional().describe("Filter by tags (e.g., ['productivity', 'git'])"),
+      limit: z.number().optional().describe("Max results to return (default 10, max 50)")
+    },
+    async ({ query, platform, tags, limit }) => {
+      const params = {
+        q: query,
+        platform,
+        tags,
+        limit: limit ?? 10
+      };
+      const result = await api.get("/artifacts/search", params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "get_artifact",
+    "Get full details for a specific CAIK artifact by its slug. Returns the complete artifact including manifest, install instructions, family info, quality scores, and content. Use after 'search' to get details on a specific result.",
+    {
+      slug: z.string().describe("Artifact slug (e.g., 'github-pr-review-skill')")
+    },
+    async ({ slug }) => {
+      const result = await api.get(`/artifacts/${encodeURIComponent(slug)}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "get_family",
+    "Get all variants (forks) of an artifact family, ranked by relevance to your platform and co-installed artifacts. Use this to compare alternatives and pick the best variant for your setup.",
+    {
+      family_id: z.string().describe("Family ID (found in artifact detail's familyId field)"),
+      platform: z.string().optional().describe("Your platform for ranking relevance: 'claude-code', 'cursor', 'windsurf', 'codex', 'generic'"),
+      co_installs: z.array(z.string()).optional().describe("Slugs of artifacts you already have installed, for compatibility ranking")
+    },
+    async ({ family_id, platform, co_installs }) => {
+      const params = {
+        platform,
+        co_installs
+      };
+      const result = await api.get(`/artifacts/family/${encodeURIComponent(family_id)}`, params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "resolve_stack",
+    "Resolve a CAIK stack into its ordered list of artifacts with install sequence. Stacks are curated collections of artifacts that work well together. Returns the full dependency-ordered install list.",
+    {
+      slug: z.string().describe("Stack slug (e.g., 'full-stack-dev-claude')"),
+      platform: z.string().optional().describe("Target platform for resolution: 'claude-code', 'cursor', 'windsurf', 'codex', 'generic'")
+    },
+    async ({ slug, platform }) => {
+      const result = await api.get(`/stacks/${encodeURIComponent(slug)}/resolve`, { platform });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/account.ts
+import { z as z2 } from "zod";
+function registerAccountTools(server, api) {
+  server.tool(
+    "get_account",
+    "Get your CAIK account info including handle, tier, karma, contribution level, and install count. Requires authentication \u2014 run 'caik init' if you haven't set up your API key.",
+    {},
+    async () => {
+      api.requireAuth();
+      const result = await api.get("/me");
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "get_stats",
+    "Get CAIK platform statistics: total artifacts, breakdown by primitive type (skills, MCP servers, prompts, etc.), total installs, and active contributor count. No authentication required.",
+    {},
+    async () => {
+      const result = await api.get("/stats");
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "get_updates",
+    "Check for available updates for an installation. Returns recommended artifact swaps, new versions, and newly published artifacts matching your profile.",
+    {
+      installation_id: z2.string().describe("Installation ID to check for updates")
+    },
+    async ({ installation_id }) => {
+      api.requireAuth();
+      const result = await api.get(`/installations/${encodeURIComponent(installation_id)}/updates`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/contribution.ts
+import { z as z3 } from "zod";
+function registerContributionTools(server, api) {
+  server.tool(
+    "report_outcome",
+    "Report the outcome of using a CAIK artifact (success/failure telemetry). This helps the community by contributing to quality scores. Fire-and-forget \u2014 does not block your workflow. Requires authentication.",
+    {
+      artifact_id: z3.string().describe("ID of the artifact that was used"),
+      success: z3.boolean().describe("Whether the artifact worked as expected"),
+      latency_ms: z3.number().optional().describe("Execution time in milliseconds (if applicable)"),
+      error_type: z3.string().optional().describe("Error category if failed (e.g., 'timeout', 'parse_error', 'runtime_error')")
+    },
+    async ({ artifact_id, success, latency_ms, error_type }) => {
+      api.requireAuth();
+      await api.post("/events", {
+        eventType: "outcome",
+        artifactId: artifact_id,
+        payload: { success, latencyMs: latency_ms, errorType: error_type }
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: "Outcome reported successfully. Thank you for contributing to the CAIK quality scores!"
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "submit_review",
+    "Submit a review (upvote or downvote) for a CAIK artifact. Helps the community evaluate artifact quality. Requires authentication with contributor+ tier. Returns karma earned for the review.",
+    {
+      artifact_slug: z3.string().describe("Slug of the artifact to review"),
+      vote: z3.enum(["up", "down"]).describe("Your vote: 'up' (helpful) or 'down' (unhelpful)"),
+      reason: z3.string().optional().describe("Brief explanation for your vote (recommended for downvotes)")
+    },
+    async ({ artifact_slug, vote, reason }) => {
+      api.requireAuth();
+      const result = await api.post(`/artifacts/${encodeURIComponent(artifact_slug)}/review`, {
+        vote,
+        reason
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/bounties.ts
+import { z as z4 } from "zod";
+function registerBountyTools(server, api) {
+  server.tool(
+    "list_bounties",
+    "List CAIK bounties \u2014 requests from the community for specific artifacts. Bounties reward karma to contributors who fulfill them. Filter by status and tags to find bounties you can fulfill.",
+    {
+      status: z4.enum(["open", "claimed", "fulfilled"]).optional().describe("Filter by bounty status (default: all)"),
+      tags: z4.array(z4.string()).optional().describe("Filter by tags (e.g., ['git', 'testing'])")
+    },
+    async ({ status, tags }) => {
+      const params = {
+        status,
+        tags
+      };
+      const result = await api.get("/bounties", params);
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "claim_bounty",
+    "Claim a CAIK bounty with a published artifact that fulfills it. You must have already published the artifact. Requires authentication. Returns confirmation with bounty details and karma reward.",
+    {
+      bounty_id: z4.string().describe("ID of the bounty to claim"),
+      artifact_slug: z4.string().describe("Slug of your published artifact that fulfills the bounty")
+    },
+    async ({ bounty_id, artifact_slug }) => {
+      api.requireAuth();
+      const result = await api.post(`/bounties/${encodeURIComponent(bounty_id)}/claim`, {
+        artifactSlug: artifact_slug
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/tools/publishing.ts
+import { z as z5 } from "zod";
+function registerPublishingTools(server, api) {
+  server.tool(
+    "submit_artifact",
+    "Publish a new artifact to the CAIK registry. Supports skills, MCP servers, prompts, commands, subagents, libraries, stacks, and references. The artifact goes through automated eval (security scan, schema validation, quality scoring). Requires authentication.",
+    {
+      name: z5.string().describe("Artifact name (human-readable, e.g., 'GitHub PR Review Skill')"),
+      description: z5.string().describe("What the artifact does \u2014 be descriptive, this helps discovery (min 20 chars)"),
+      primitive: z5.enum(["skill", "mcp-server", "prompt", "command", "subagent", "library", "stack", "reference"]).describe("Artifact type/primitive"),
+      tags: z5.array(z5.string()).min(1).describe("At least one tag for categorization (e.g., ['git', 'code-review'])"),
+      platforms: z5.array(z5.string()).min(1).describe("Supported platforms (e.g., ['claude-code', 'cursor', 'generic'])"),
+      content: z5.string().describe("The artifact content (skill source, prompt text, config, etc.)"),
+      manifest: z5.record(z5.unknown()).optional().describe("Optional manifest object with primitive-specific metadata"),
+      parentSlug: z5.string().optional().describe("If this is a fork, the slug of the parent artifact"),
+      forkRationale: z5.string().optional().describe("If forking, explain what you changed and why")
+    },
+    async ({ name, description, primitive, tags, platforms, content, manifest, parentSlug, forkRationale }) => {
+      api.requireAuth();
+      const result = await api.post("/artifacts", {
+        name,
+        description,
+        primitive,
+        tags,
+        platforms,
+        content,
+        manifest,
+        parentSlug,
+        forkRationale: forkRationale ? { category: "custom", description: forkRationale } : void 0
+      });
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_my_artifacts",
+    "List all artifacts you've published to CAIK. Returns slug, name, quality score, install count, and status for each. Requires authentication.",
+    {},
+    async () => {
+      api.requireAuth();
+      const result = await api.get("/me/artifacts");
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.tool(
+    "list_my_submissions",
+    "Get a summary of your CAIK submission pipeline: how many artifacts are pending review, published, or still in draft. Requires authentication.",
+    {},
+    async () => {
+      api.requireAuth();
+      const result = await api.get("/me/submissions");
+      return {
+        content: [
+          {
+            type: "text",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/resources.ts
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+function registerResources(server, api) {
+  server.resource(
+    "artifact",
+    new ResourceTemplate("caik://artifact/{slug}", { list: void 0 }),
+    {
+      description: "Full artifact detail from the CAIK registry",
+      mimeType: "application/json"
+    },
+    async (uri, { slug }) => {
+      const result = await api.get(`/artifacts/${encodeURIComponent(slug)}`);
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+  server.resource(
+    "stack",
+    new ResourceTemplate("caik://stack/{slug}", { list: void 0 }),
+    {
+      description: "Resolved stack with ordered artifact install sequence",
+      mimeType: "application/json"
+    },
+    async (uri, { slug }) => {
+      const result = await api.get(`/stacks/${encodeURIComponent(slug)}/resolve`);
+      return {
+        contents: [
+          {
+            uri: uri.href,
+            mimeType: "application/json",
+            text: JSON.stringify(result, null, 2)
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/prompts.ts
+import { z as z6 } from "zod";
+function registerPrompts(server) {
+  server.prompt(
+    "discover",
+    "Help me find AI agent tools, skills, or MCP servers for my setup",
+    {
+      category: z6.string().optional().describe("Category to search: 'skills', 'mcp-servers', 'prompts', 'libraries', 'stacks', or a specific domain like 'git', 'testing'"),
+      platform: z6.string().optional().describe("Your agent platform: 'claude-code', 'cursor', 'windsurf', 'codex', 'generic'")
+    },
+    ({ category, platform }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `Help me find ${category ?? "tools and skills"} for my ${platform ?? "AI agent"} setup.
+
+Use the CAIK 'search' tool to find relevant artifacts. Show me the top results with their quality scores, install counts, and a brief description of each. If there are artifact families with multiple variants, mention which variant is best for my platform.`
+          }
+        }
+      ]
+    })
+  );
+  server.prompt(
+    "setup",
+    "Set up a complete agent stack for a specific use case",
+    {
+      use_case: z6.string().describe("What you want to build or accomplish (e.g., 'full-stack web development', 'data analysis pipeline')"),
+      platform: z6.string().optional().describe("Your agent platform: 'claude-code', 'cursor', 'windsurf', 'codex', 'generic'")
+    },
+    ({ use_case, platform }) => ({
+      messages: [
+        {
+          role: "user",
+          content: {
+            type: "text",
+            text: `I want to set up a complete agent stack for: ${use_case}
+Platform: ${platform ?? "generic"}
+
+Please:
+1. Search CAIK for relevant stacks using the 'search' tool with appropriate keywords
+2. If a stack exists, use 'resolve_stack' to get the full install sequence
+3. If no stack exists, search for individual artifacts and recommend a combination
+4. For each recommended artifact, show the quality score and install count
+5. Provide the install sequence in order`
+          }
+        }
+      ]
+    })
+  );
+  server.prompt(
+    "contribute",
+    "Publish a new or forked artifact to the CAIK registry",
+    {
+      action: z6.enum(["new", "fork"]).optional().describe("Whether you're publishing a new artifact or forking an existing one"),
+      parent_slug: z6.string().optional().describe("If forking, the slug of the artifact to fork from")
+    },
+    ({ action, parent_slug }) => {
+      const isFork = action === "fork" || !!parent_slug;
+      const forkContext = isFork ? `
+I'm forking from: ${parent_slug ?? "(specify the parent artifact slug)"}
+
+First, use 'get_artifact' to fetch the parent artifact details so we can see what we're building on.` : "";
+      return {
+        messages: [
+          {
+            role: "user",
+            content: {
+              type: "text",
+              text: `I want to ${isFork ? "fork an existing artifact and publish my modified version" : "publish a new artifact"} to the CAIK registry.${forkContext}
+
+Walk me through the process:
+1. Help me prepare the artifact metadata (name, description, tags, platforms, primitive type)
+2. Review the content for quality (description > 20 chars, at least 1 tag, valid primitive)
+3. Use 'submit_artifact' to publish it
+4. Verify the submission with 'list_my_submissions'`
+            }
+          }
+        ]
+      };
+    }
+  );
+}
+
+// src/index.ts
+function createServer() {
+  const config = resolveConfig();
+  const api = new CaikApiClient(config);
+  const server = new McpServer({
+    name: "caik",
+    version: "0.1.0"
+  });
+  registerDiscoveryTools(server, api);
+  registerAccountTools(server, api);
+  registerContributionTools(server, api);
+  registerBountyTools(server, api);
+  registerPublishingTools(server, api);
+  registerResources(server, api);
+  registerPrompts(server);
+  return server;
+}
+async function main() {
+  const server = createServer();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+}
+main().catch((err) => {
+  console.error("CAIK MCP Server failed to start:", err);
+  process.exit(1);
+});
+export {
+  createServer
+};

package/package.json

@@ -0,0 +1,45 @@
+{
+  "name": "@caik.dev/mcp",
+  "version": "0.1.0",
+  "type": "module",
+  "description": "CAIK MCP Server — AI artifact registry tools for Claude Code, Cursor, and other MCP-capable agents",
+  "keywords": [
+    "caik",
+    "mcp",
+    "ai",
+    "artifacts",
+    "claude",
+    "cursor",
+    "skills",
+    "registry",
+    "model-context-protocol"
+  ],
+  "homepage": "https://caik.dev",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/open-lattice-ai/caik",
+    "directory": "packages/mcp"
+  },
+  "license": "MIT",
+  "bin": {
+    "caik-mcp-server": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md"
+  ],
+  "main": "./dist/index.js",
+  "scripts": {
+    "build": "tsup",
+    "dev": "tsx src/index.ts",
+    "typecheck": "tsc --noEmit"
+  },
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.12.1",
+    "zod": "^3.24.0"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.1",
+    "tsx": "^4.21.0"
+  }
+}