@happyvertical/sdk-mcp 0.74.8

package/AGENT.md

@@ -0,0 +1,33 @@
+# @happyvertical/sdk-mcp
+
+<!-- BEGIN AGENT:GENERATED -->
+## Purpose
+MCP server for HAVE SDK - Routes queries to package experts using AGENT.md files
+
+## Package Map
+- Package: `@happyvertical/sdk-mcp`
+- Hierarchy path: `@happyvertical/sdk > packages > sdk-mcp`
+- Workspace position: `23 of 30` local packages
+- Internal dependencies: `@happyvertical/ai`, `@happyvertical/files`, `@happyvertical/utils`
+- Internal dependents: none
+- Knowledge graph files: `AGENT.md`, `metadata.json`, `ecosystem-manifest.json`
+
+## Build & Test
+```bash
+pnpm --filter @happyvertical/sdk-mcp build
+pnpm --filter @happyvertical/sdk-mcp test
+pnpm --filter @happyvertical/sdk-mcp clean
+```
+
+## Agent Correction Loops
+- If module resolution or export errors mention a workspace dependency, build the dependency first (`pnpm --filter @happyvertical/ai build`, `pnpm --filter @happyvertical/files build`, `pnpm --filter @happyvertical/utils build`) and then rerun `pnpm --filter @happyvertical/sdk-mcp build`.
+- If tests or exports fail after API, type, or bundle changes, run `pnpm --filter @happyvertical/sdk-mcp clean` followed by `pnpm --filter @happyvertical/sdk-mcp build` and `pnpm --filter @happyvertical/sdk-mcp test`.
+- If failures span multiple packages or Turborepo ordering looks wrong, run `pnpm build` and `pnpm typecheck` from the repo root before retrying package-scoped commands.
+
+## Ecosystem Relationships
+- Provides: MCP server for HAVE SDK - Routes queries to package experts using AGENT.md files
+- Implements: none
+- Requires: @happyvertical/ai, @happyvertical/files, @happyvertical/utils, @modelcontextprotocol/sdk
+- Stability: stable (Primary package surface is described as implemented and production-oriented.)
+<!-- END AGENT:GENERATED -->
+

package/LICENSE

@@ -0,0 +1,7 @@
+Copyright <2025> <Happy Vertical Corporation>
+
+Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the “Software”), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED “AS IS”, WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.

package/README.md

@@ -0,0 +1,135 @@
+# @happyvertical/sdk-mcp
+
+MCP server for the HAVE SDK that routes developer queries to package documentation. It scans each package's `AGENT.md` file at startup, builds a keyword-indexed registry, and exposes three MCP tools: `ask` (AI-powered Q&A), `list-packages`, and `get-docs`.
+
+## Installation
+
+```bash
+pnpm install @happyvertical/sdk-mcp
+```
+
+> Published to public npm. No scoped registry configuration is required.
+
+## Usage
+
+### As an MCP Server
+
+The package provides a stdio-based MCP server. Run it directly:
+
+```bash
+npx sdk-mcp
+```
+
+Or configure it in your MCP client (e.g., Claude Desktop) to launch as a subprocess.
+
+### Claude Code Context CLI
+
+Copy AGENT.md and metadata into your project's `.claude/` directory for AI-assisted development:
+
+```bash
+npx have-sdk-mcp-context
+```
+
+### Environment Variables
+
+The `ask` tool requires an AI provider. Set one of:
+
+- `HAVE_AI_API_KEY` — Fallback API key for any provider
+- `HAVE_AI_TYPE` — Provider type (`openai`, `anthropic`, `gemini`)
+- `OPENAI_API_KEY`, `ANTHROPIC_API_KEY`, or `GEMINI_API_KEY`
+
+The `list-packages` and `get-docs` tools work without AI configuration.
+
+## MCP Tools
+
+### ask
+
+Ask a question about the SDK. Routes to relevant packages via keyword matching and synthesizes a response using AI (top 3 matches).
+
+```json
+{
+  "query": "How do I send an email with an attachment?",
+  "packages": ["email", "messages"]
+}
+```
+
+- `query` (required) — The question to ask
+- `packages` (optional) — Explicit package names to consult instead of auto-routing
+
+### list-packages
+
+List all discovered SDK packages with descriptions and keywords. No parameters.
+
+### get-docs
+
+Get the full AGENT.md content for a specific package.
+
+```json
+{
+  "packageName": "ai"
+}
+```
+
+## How It Works
+
+1. **Registry** — On first call, scans `packages/*/AGENT.md` and builds a `Map<string, PackageMetadata>` keyed by package name. Each entry includes the description (extracted from AGENT.md), keywords (from a static mapping in `registry.ts`), and the full documentation content.
+
+2. **Routing** — Splits the user query into tokens and scores each package by keyword overlap (exact match = 10 pts, partial = 5 pts, name bonus = 15 pts). Packages below a minimum score threshold are excluded.
+
+3. **Synthesis** — The `ask` tool loads AGENT.md for the top 3 matched packages, builds a system prompt with that context, and calls `@happyvertical/ai` to generate a response.
+
+## Adding a New Package
+
+1. Create an `AGENT.md` in the new package directory
+2. Add a keyword entry in `src/registry.ts` (`PACKAGE_KEYWORDS`)
+3. Rebuild: `pnpm run build`
+
+The package will be discovered automatically on the next server startup.
+
+## API
+
+### Registry (`registry.ts`)
+
+| Export | Description |
+|--------|-------------|
+| `PackageMetadata` | Interface: `name`, `path`, `description`, `claudeMd`, `keywords` |
+| `PACKAGE_KEYWORDS` | Static keyword-to-package mapping used for routing |
+| `buildPackageRegistry()` | Scans packages directory and returns cached `Map<string, PackageMetadata>` |
+| `getPackage(name)` | Get metadata for a single package |
+| `getAllPackages()` | Get all package metadata as an array |
+| `getPackageDocs(name)` | Get raw AGENT.md content for a package |
+| `clearCache()` | Clear the in-memory registry cache |
+
+### Router (`router.ts`)
+
+| Export | Description |
+|--------|-------------|
+| `PackageMatch` | Interface: `package`, `score`, `matchedKeywords` |
+| `routeQuery(query, minScore?)` | Score and rank packages against a query string |
+| `getPackagesByNames(names)` | Look up packages by explicit name list |
+| `getTopPackages(query, limit?)` | Shorthand for `routeQuery` + slice |
+
+### Tools (`tools/`)
+
+| Export | Description |
+|--------|-------------|
+| `ask(input)` | AI-powered Q&A tool |
+| `listPackages()` | List all packages |
+| `getDocs(packageName)` | Get package documentation |
+
+## Dependencies
+
+- `@happyvertical/ai` — AI provider for the `ask` tool
+- `@modelcontextprotocol/sdk` — MCP protocol implementation
+
+## Development
+
+```bash
+pnpm run build       # Build
+pnpm test            # Run tests
+pnpm run dev         # Watch mode (build + test)
+```
+
+## License
+
+MIT

package/dist/claude-context.d.ts

@@ -0,0 +1 @@
+export { }

package/dist/cli/claude-context.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=claude-context.d.ts.map

package/dist/cli/claude-context.js

@@ -0,0 +1,20 @@
+#!/usr/bin/env node
+import { existsSync, mkdirSync, copyFileSync } from "node:fs";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const Dirname = dirname(fileURLToPath(import.meta.url));
+const pkgRoot = join(Dirname, "../..");
+const targetDir = join(process.cwd(), ".claude");
+if (!existsSync(targetDir)) {
+  mkdirSync(targetDir, { recursive: true });
+}
+const pkgName = "sdk-mcp";
+const agentMdSrc = existsSync(join(pkgRoot, "AGENT.md")) ? join(pkgRoot, "AGENT.md") : join(pkgRoot, "CLAUDE.md");
+const metaSrc = existsSync(join(pkgRoot, "metadata.json")) ? join(pkgRoot, "metadata.json") : join(pkgRoot, ".claude-meta.json");
+if (existsSync(agentMdSrc)) {
+  copyFileSync(agentMdSrc, join(targetDir, `have-${pkgName}.md`));
+}
+if (existsSync(metaSrc)) {
+  copyFileSync(metaSrc, join(targetDir, `have-${pkgName}.meta.json`));
+}
+console.log(`✓ Installed @happyvertical/${pkgName} context to .claude/`);

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+/* Excluded from this release type: PACKAGE_VERSION_INITIALIZED */
+
+export { }

package/dist/index.js

@@ -0,0 +1,533 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { ListToolsRequestSchema, CallToolRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { getAI } from "@happyvertical/ai";
+import { readdir, readFile } from "node:fs/promises";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+const Filename = fileURLToPath(import.meta.url);
+const Dirname = dirname(Filename);
+const PACKAGE_KEYWORDS = {
+  ai: [
+    "ai",
+    "llm",
+    "gpt",
+    "claude",
+    "openai",
+    "anthropic",
+    "model",
+    "completion",
+    "chat",
+    "embedding",
+    "gemini",
+    "bedrock",
+    "huggingface"
+  ],
+  sql: [
+    "database",
+    "sql",
+    "sqlite",
+    "postgres",
+    "duckdb",
+    "query",
+    "table",
+    "schema",
+    "json"
+  ],
+  files: [
+    "file",
+    "filesystem",
+    "read",
+    "write",
+    "download",
+    "upload",
+    "path",
+    "storage"
+  ],
+  spider: [
+    "crawl",
+    "scrape",
+    "web",
+    "html",
+    "website",
+    "page",
+    "link",
+    "civicweb"
+  ],
+  pdf: ["pdf", "document", "extract", "parse", "acrobat"],
+  ocr: ["ocr", "image", "text extraction", "tesseract", "vision"],
+  geo: ["location", "map", "coordinates", "geocode", "address", "gis"],
+  translator: ["translate", "language", "translation", "localization"],
+  weather: [
+    "weather",
+    "forecast",
+    "temperature",
+    "precipitation",
+    "conditions",
+    "wind",
+    "humidity",
+    "openweathermap",
+    "environment canada"
+  ],
+  utils: ["id", "uuid", "slug", "date", "format", "utility", "helper"],
+  cache: ["cache", "caching", "redis", "memory", "store"],
+  logger: ["log", "logging", "logger", "debug", "error"],
+  documents: ["document processing", "content extraction", "analysis"],
+  email: [
+    "email",
+    "mail",
+    "smtp",
+    "imap",
+    "pop3",
+    "gmail",
+    "mailbox",
+    "send",
+    "receive",
+    "inbox",
+    "folder"
+  ],
+  "github-actions": [
+    "github",
+    "actions",
+    "workflow",
+    "ci",
+    "cd",
+    "automation",
+    "issue",
+    "pr",
+    "pull request",
+    "triage"
+  ],
+  directory: [
+    "directory",
+    "identity",
+    "provisioning",
+    "kanidm",
+    "stalwart",
+    "postgres",
+    "aws",
+    "iam",
+    "user",
+    "group",
+    "oauth",
+    "mail",
+    "domain",
+    "dkim",
+    "role",
+    "tenant"
+  ],
+  analytics: [
+    "analytics",
+    "tracking",
+    "ga4",
+    "google analytics",
+    "plausible",
+    "metrics",
+    "dimensions",
+    "report",
+    "pageview",
+    "event",
+    "conversion",
+    "measurement protocol"
+  ]
+};
+const packageCache = /* @__PURE__ */ new Map();
+function getSDKRoot() {
+  return join(Dirname, "..", "..", "..");
+}
+function extractDescription(content) {
+  const purposeMatch = content.match(
+    /##\s+Purpose and Responsibilities\s+([^\n]+(?:\n(?!##)[^\n]+)*)/i
+  );
+  if (purposeMatch) {
+    const purpose = purposeMatch[1].trim().replace(/\n/g, " ").replace(/\s+/g, " ");
+    const firstSentence = purpose.match(/^[^.!?]+[.!?]/);
+    if (firstSentence) {
+      return firstSentence[0].trim();
+    }
+    return `${purpose.substring(0, 200).trim()}...`;
+  }
+  const lines = content.split("\n");
+  let foundTitle = false;
+  for (const line of lines) {
+    if (line.startsWith("# ") || line.startsWith("## ")) {
+      foundTitle = true;
+      continue;
+    }
+    if (foundTitle && line.trim().length > 0 && !line.startsWith("#")) {
+      return line.trim();
+    }
+  }
+  return "No description available";
+}
+async function buildPackageRegistry() {
+  if (packageCache.size > 0) {
+    return packageCache;
+  }
+  const sdkRoot = getSDKRoot();
+  const packagesDir = join(sdkRoot, "packages");
+  try {
+    const entries = await readdir(packagesDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (!entry.isDirectory()) continue;
+      const packageName = entry.name;
+      const agentMdPath = join(packagesDir, packageName, "AGENT.md");
+      const legacyClaudePath = join(packagesDir, packageName, "CLAUDE.md");
+      try {
+        let agentMd;
+        try {
+          agentMd = await readFile(agentMdPath, "utf-8");
+        } catch {
+          agentMd = await readFile(legacyClaudePath, "utf-8");
+        }
+        const description = extractDescription(agentMd);
+        const keywords = PACKAGE_KEYWORDS[packageName] || [];
+        packageCache.set(packageName, {
+          name: packageName,
+          path: join(packagesDir, packageName),
+          description,
+          agentMd,
+          keywords
+        });
+      } catch (_error) {
+      }
+    }
+    return packageCache;
+  } catch (error) {
+    throw new Error(
+      `Failed to build package registry: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+async function getPackage(name) {
+  const registry = await buildPackageRegistry();
+  return registry.get(name);
+}
+async function getAllPackages() {
+  const registry = await buildPackageRegistry();
+  return Array.from(registry.values());
+}
+async function getPackageDocs(name) {
+  const pkg = await getPackage(name);
+  return pkg?.agentMd;
+}
+function extractQueryKeywords(query) {
+  return query.toLowerCase().split(/\W+/).filter((word) => word.length > 2);
+}
+function calculateScore(queryKeywords, packageKeywords) {
+  const matched = [];
+  let score = 0;
+  for (const queryKeyword of queryKeywords) {
+    for (const packageKeyword of packageKeywords) {
+      if (queryKeyword === packageKeyword) {
+        score += 10;
+        matched.push(packageKeyword);
+      } else if (queryKeyword.includes(packageKeyword) || packageKeyword.includes(queryKeyword)) {
+        score += 5;
+        if (!matched.includes(packageKeyword)) {
+          matched.push(packageKeyword);
+        }
+      }
+    }
+  }
+  for (const queryKeyword of queryKeywords) {
+    if (packageKeywords.some((pkg) => pkg.toLowerCase() === queryKeyword)) {
+      score += 15;
+    }
+  }
+  return { score, matched };
+}
+async function routeQuery(query, minScore = 5) {
+  const packages = await getAllPackages();
+  const queryKeywords = extractQueryKeywords(query);
+  const matches = [];
+  for (const pkg of packages) {
+    const { score, matched } = calculateScore(queryKeywords, pkg.keywords);
+    if (score >= minScore) {
+      matches.push({
+        package: pkg,
+        score,
+        matchedKeywords: matched
+      });
+    }
+  }
+  matches.sort((a, b) => b.score - a.score);
+  return matches;
+}
+async function getPackagesByNames(names) {
+  const packages = await getAllPackages();
+  const nameSet = new Set(names.map((n) => n.toLowerCase()));
+  return packages.filter((pkg) => nameSet.has(pkg.name.toLowerCase()));
+}
+async function getAIClient() {
+  try {
+    return await getAI({});
+  } catch (error) {
+    throw new Error(
+      `AI client initialization failed. Please configure AI provider using HAVE_AI_* environment variables. Error: ${error instanceof Error ? error.message : String(error)}`
+    );
+  }
+}
+function buildContext(packages) {
+  if (packages.length === 0) {
+    return "No relevant packages found.";
+  }
+  const contextParts = [];
+  for (const pkg of packages) {
+    contextParts.push(
+      `## Package: @happyvertical/${pkg.name}
+
+${pkg.agentMd}
+
+---
+`
+    );
+  }
+  return contextParts.join("\n");
+}
+async function ask(input) {
+  const { query, packages: requestedPackages } = input;
+  try {
+    let packages;
+    if (requestedPackages && requestedPackages.length > 0) {
+      packages = await getPackagesByNames(requestedPackages);
+      if (packages.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `None of the requested packages (${requestedPackages.join(", ")}) were found. Use list-packages to see available packages.`
+            }
+          ],
+          isError: true
+        };
+      }
+    } else {
+      const matches = await routeQuery(query);
+      if (matches.length === 0) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `No relevant packages found for query: "${query}". Try using list-packages to browse available packages or specify packages explicitly.`
+            }
+          ],
+          isError: false
+        };
+      }
+      packages = matches.slice(0, 3).map((m) => m.package);
+    }
+    const context = buildContext(packages);
+    const ai = await getAIClient();
+    const systemPrompt = `You are an expert SDK documentation assistant for the HAppy VErtical (HAVE) SDK.
+You have access to the full documentation (AGENT.md files) for the following packages: ${packages.map((p) => `@happyvertical/${p.name}`).join(", ")}.
+
+Your role is to:
+1. Answer questions about the SDK using the provided package documentation
+2. Provide code examples when relevant
+3. Reference specific packages and documentation sections
+4. Be concise but thorough
+5. Include package names in your response (e.g., "@happyvertical/ai", "@happyvertical/sql")
+
+Use the documentation provided below to answer the user's question accurately.
+
+---
+${context}
+---`;
+    const response = await ai.chat(
+      [
+        { role: "system", content: systemPrompt },
+        { role: "user", content: query }
+      ],
+      {
+        temperature: 0.7,
+        maxTokens: 2e3
+      }
+    );
+    const packageList = packages.map((p) => `@happyvertical/${p.name}`).join(", ");
+    const footer = `
+
+---
+*Consulted packages: ${packageList}*`;
+    return {
+      content: [
+        {
+          type: "text",
+          text: response.content + footer
+        }
+      ]
+    };
+  } catch (error) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Error processing query: ${error instanceof Error ? error.message : String(error)}`
+        }
+      ],
+      isError: true
+    };
+  }
+}
+async function getDocs(packageName) {
+  const docs = await getPackageDocs(packageName);
+  if (!docs) {
+    return {
+      content: [
+        {
+          type: "text",
+          text: `Package "${packageName}" not found. Use list-packages to see available packages.`
+        }
+      ],
+      isError: true
+    };
+  }
+  return {
+    content: [
+      {
+        type: "text",
+        text: docs
+      }
+    ]
+  };
+}
+async function listPackages() {
+  const packages = await getAllPackages();
+  return {
+    content: [
+      {
+        type: "text",
+        text: JSON.stringify(
+          {
+            packages: packages.map((pkg) => ({
+              name: pkg.name,
+              description: pkg.description,
+              keywords: pkg.keywords
+            })),
+            total: packages.length
+          },
+          null,
+          2
+        )
+      }
+    ]
+  };
+}
+class SDKMCPServer {
+  server;
+  constructor() {
+    this.server = new Server(
+      {
+        name: "happyvertical-sdk-mcp",
+        version: "0.1.0"
+      },
+      {
+        capabilities: {
+          tools: {}
+        }
+      }
+    );
+    this.setupToolHandlers();
+    this.setupErrorHandling();
+  }
+  setupToolHandlers() {
+    this.server.setRequestHandler(ListToolsRequestSchema, async () => ({
+      tools: [
+        {
+          name: "ask",
+          description: "Ask a question about the HAVE SDK. Automatically routes your query to relevant package experts (AGENT.md files) and synthesizes a response using AI.",
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: "Your question about SDK usage or capabilities"
+              },
+              packages: {
+                type: "array",
+                items: { type: "string" },
+                description: 'Optional: Specific packages to consult (e.g., ["ai", "sql"])'
+              }
+            },
+            required: ["query"]
+          }
+        },
+        {
+          name: "list-packages",
+          description: "List all available SDK packages with their descriptions and keywords",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "get-docs",
+          description: "Get the full AGENT.md documentation for a specific package",
+          inputSchema: {
+            type: "object",
+            properties: {
+              packageName: {
+                type: "string",
+                description: 'Name of the package (e.g., "ai", "sql", "spider")'
+              }
+            },
+            required: ["packageName"]
+          }
+        }
+      ]
+    }));
+    this.server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      try {
+        switch (request.params.name) {
+          case "ask": {
+            const input = request.params.arguments ?? {};
+            return await ask(input);
+          }
+          case "list-packages": {
+            return await listPackages();
+          }
+          case "get-docs": {
+            const args = request.params.arguments ?? {};
+            return await getDocs(args.packageName);
+          }
+          default:
+            throw new Error(`Unknown tool: ${request.params.name}`);
+        }
+      } catch (error) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Error executing tool: ${error instanceof Error ? error.message : String(error)}`
+            }
+          ],
+          isError: true
+        };
+      }
+    });
+  }
+  setupErrorHandling() {
+    this.server.onerror = (error) => {
+      console.error("[MCP Error]", error);
+    };
+    process.on("SIGINT", async () => {
+      await this.server.close();
+      process.exit(0);
+    });
+  }
+  async run() {
+    const transport = new StdioServerTransport();
+    await this.server.connect(transport);
+    console.error("HappyVertical SDK MCP Server running on stdio");
+  }
+}
+const server = new SDKMCPServer();
+server.run().catch((error) => {
+  console.error("Fatal error:", error);
+  process.exit(1);
+});
+const PACKAGE_VERSION_INITIALIZED = true;
+export {
+  PACKAGE_VERSION_INITIALIZED
+};

package/metadata.json

@@ -0,0 +1,33 @@
+{
+  "name": "@happyvertical/sdk-mcp",
+  "path": "packages/sdk-mcp",
+  "position": {
+    "index": 23,
+    "count": 30
+  },
+  "description": "MCP server for HAVE SDK - Routes queries to package experts using AGENT.md files",
+  "provides": [
+    "MCP server for HAVE SDK - Routes queries to package experts using AGENT.md files"
+  ],
+  "implements": [],
+  "requires": {
+    "workspace": [
+      "@happyvertical/ai",
+      "@happyvertical/files",
+      "@happyvertical/utils"
+    ],
+    "externalHappyVertical": [],
+    "external": [
+      "@modelcontextprotocol/sdk"
+    ]
+  },
+  "dependents": [],
+  "stability": {
+    "level": "stable",
+    "reason": "Primary package surface is described as implemented and production-oriented."
+  },
+  "keywords": [
+    "sdk",
+    "mcp"
+  ]
+}

package/package.json

@@ -0,0 +1,60 @@
+{
+  "name": "@happyvertical/sdk-mcp",
+  "version": "0.74.8",
+  "description": "MCP server for HAVE SDK - Routes queries to package experts using AGENT.md files",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "bin": {
+    "sdk-mcp": "./dist/index.js",
+    "have-sdk-mcp-context": "./dist/cli/claude-context.js"
+  },
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    }
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE",
+    "AGENT.md",
+    "metadata.json"
+  ],
+  "publishConfig": {
+    "registry": "https://registry.npmjs.org",
+    "access": "public"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/happyvertical/sdk.git",
+    "directory": "packages/sdk-mcp"
+  },
+  "bugs": {
+    "url": "https://github.com/happyvertical/sdk/issues"
+  },
+  "homepage": "https://github.com/happyvertical/sdk/tree/main/packages/sdk-mcp#readme",
+  "license": "MIT",
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "1.29.0",
+    "@happyvertical/utils": "0.74.8",
+    "@happyvertical/ai": "0.74.8",
+    "@happyvertical/files": "0.74.8"
+  },
+  "devDependencies": {
+    "@types/node": "25.0.10",
+    "typescript": "^5.9.3",
+    "vite": "7.3.2",
+    "vite-plugin-dts": "4.5.4",
+    "vitest": "^4.1.5"
+  },
+  "scripts": {
+    "test": "npx vitest run --passWithNoTests",
+    "test:watch": "npx vitest",
+    "build": "vite build",
+    "build:watch": "vite build --watch",
+    "clean": "rm -rf dist",
+    "dev": "npm run build:watch & npm run test:watch"
+  }
+}