react-native-docs-mcp 0.1.0

package/README.md

@@ -0,0 +1,133 @@
+<p align="center">
+  <img src="../../poster.png" width="100%" alt="React Native Docs MCP">
+</p>
+
+# React Native Docs MCP Server
+
+AI-powered semantic search over React Native documentation for Claude, Cursor, and other MCP clients.
+
+Looking for React docs instead? See [react-docs-mcp](https://www.npmjs.com/package/react-docs-mcp).
+
+## 🚀 Installation (One Command)
+
+### Claude Code
+
+```bash
+claude mcp add --transport stdio react-native-docs -- npx react-native-docs-mcp
+```
+
+### Claude Desktop
+
+Edit: `~/Library/Application Support/Claude/claude_desktop_config.json` (macOS) or `%APPDATA%\Claude\claude_desktop_config.json` (Windows)
+
+```json
+{
+  "mcpServers": {
+    "react-native-docs": {
+      "command": "npx",
+      "args": ["-y", "react-native-docs-mcp"]
+    }
+  }
+}
+```
+
+### Cursor
+
+**Settings** → **Cursor settings** → **Tools and MCP** → Add server:
+
+```json
+{
+  "mcpServers": {
+    "react-native-docs": {
+      "command": "npx",
+      "args": ["-y", "react-native-docs-mcp"]
+    }
+  }
+}
+```
+
+**That's it!** Restart your editor and ask about React Native.
+
+---
+
+## Features
+
+- **🔍 Semantic Search**: AI-powered search using embeddings for conceptual matches
+- **⚡ Fast Results**: In-memory vector search with hybrid keyword+semantic ranking
+- **📦 Zero Config**: Works with `npx` - no installation needed
+- **🤖 Local AI**: Runs embeddings locally (no API costs)
+- **📝 Concise Responses**: Returns summaries instead of full documentation
+- **🔄 Auto-sync**: Pulls latest docs from the react-native-website repo automatically
+
+## Usage
+
+Once configured, the server provides the following capabilities to AI agents:
+
+### Tools
+
+#### `search_react_native_docs`
+
+Search across React Native documentation.
+
+**Parameters**:
+
+- `query` (required): Search query string
+- `section` (optional): Filter by section (the-new-architecture, legacy, releases)
+- `limit` (optional): Maximum number of results (default: 10, max: 50)
+
+**Example**:
+
+```
+Search for "flexbox layout" in React Native docs
+```
+
+#### `get_doc`
+
+Get a specific documentation page.
+
+**Parameters**:
+
+- `path` (required): Document path (e.g., "getting-started", "the-new-architecture/using-codegen")
+
+**Example**:
+
+```
+Get the React Native flexbox documentation
+```
+
+#### `list_sections`
+
+List all available documentation sections.
+
+#### `update_docs`
+
+Pull latest documentation from the Git repository.
+
+### Resources
+
+The server exposes documentation as resources with the URI pattern:
+
+```
+react-native-docs://{section}/{path}
+```
+
+## Limitations
+
+- **Docs source**: content is cloned from the unversioned `docs/` folder in [facebook/react-native-website](https://github.com/facebook/react-native-website), which is upstream's live editing source. It may occasionally be a few days ahead of the latest published release rather than pinned to a specific React Native version.
+- **Sections**: most React Native docs pages live flat at the root of `docs/` with no meaningful section — only `the-new-architecture`, `legacy`, and `releases` are real subfolders. The `section` filter reliably narrows results only for those three; for everything else, search unfiltered.
+- **Blog posts**: `website/blog/` is not indexed yet.
+- **MDX rendering**: `.mdx`-only syntax (JSX component imports, admonitions) is stripped as best-effort plain text for search indexing, so snippets/summaries for some pages may include stray import lines.
+
+## Development
+
+This package shares its engine (`src/`) with the root [react-docs-mcp](../../) project in this repo — see that project's README for the underlying architecture. This package's own source only configures the shared engine with React Native-specific defaults (`src/index.ts`) and is bundled standalone with [tsup](https://tsup.egoist.dev/).
+
+```bash
+npm install
+npm run build
+npm run dev   # run directly with tsx, no build step
+```
+
+## License
+
+MIT. React Native documentation content is © Meta Platforms, Inc. and licensed separately by the [react-native-website](https://github.com/facebook/react-native-website) project.

package/dist/index.js

@@ -0,0 +1,958 @@
+#!/usr/bin/env node
+
+// ../../src/config.ts
+import { homedir } from "os";
+import { join } from "path";
+var getCacheDir = (cacheDirName) => {
+  const platform = process.platform;
+  const home = homedir();
+  if (platform === "darwin" || platform === "linux") {
+    return join(home, ".cache", cacheDirName);
+  } else if (platform === "win32") {
+    return join(process.env.LOCALAPPDATA || join(home, "AppData", "Local"), cacheDirName);
+  }
+  return join(home, `.${cacheDirName}`);
+};
+function resolve(preset) {
+  const { cacheDirName, repoFolderName, repo, ...rest } = preset;
+  return {
+    ...rest,
+    repo: {
+      url: repo.url,
+      contentPath: repo.contentPath,
+      localPath: join(getCacheDir(cacheDirName), repoFolderName)
+    }
+  };
+}
+var defaultPreset = {
+  cacheDirName: "react-docs-mcp",
+  repoFolderName: "react-dev-repo",
+  repo: {
+    url: "https://github.com/reactjs/react.dev.git",
+    contentPath: "src/content"
+  },
+  search: {
+    defaultLimit: 10,
+    maxLimit: 50,
+    minScore: 0.1,
+    semanticSearchEnabled: true,
+    semanticMinSimilarity: 0.3,
+    hybridKeywordWeight: 0.3,
+    hybridSemanticWeight: 0.7
+  },
+  server: {
+    name: "react-docs-mcp",
+    version: "1.0.0"
+  },
+  sections: ["learn", "reference", "blog", "community"],
+  resourceUriScheme: "react-docs",
+  docsLabel: "React",
+  searchToolName: "search_react_docs",
+  searchToolDescription: "Search across React documentation. Returns relevant documentation pages with snippets.",
+  docUrl: { base: "https://react.dev", useFrontmatterId: false }
+};
+var activeConfig = resolve(defaultPreset);
+function configure(preset) {
+  activeConfig = resolve(preset);
+}
+
+// ../../src/presets/reactNativeDocs.ts
+var reactNativeDocsPreset = {
+  cacheDirName: "react-native-docs-mcp",
+  repoFolderName: "react-native-website-repo",
+  repo: {
+    url: "https://github.com/facebook/react-native-website.git",
+    contentPath: "docs"
+  },
+  search: {
+    defaultLimit: 10,
+    maxLimit: 50,
+    minScore: 0.1,
+    semanticSearchEnabled: true,
+    semanticMinSimilarity: 0.3,
+    hybridKeywordWeight: 0.3,
+    hybridSemanticWeight: 0.7
+  },
+  server: {
+    name: "react-native-docs-mcp",
+    version: "0.1.0"
+  },
+  sections: ["the-new-architecture", "legacy", "releases"],
+  resourceUriScheme: "react-native-docs",
+  docsLabel: "React Native",
+  searchToolName: "search_react_native_docs",
+  searchToolDescription: "Search across React Native documentation. Returns relevant documentation pages with snippets.",
+  docUrl: { base: "https://reactnative.dev/docs", useFrontmatterId: true }
+};
+
+// ../../src/server.ts
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import {
+  CallToolRequestSchema,
+  ListResourcesRequestSchema,
+  ListToolsRequestSchema,
+  ReadResourceRequestSchema
+} from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+
+// ../../src/docsManager.ts
+import { simpleGit } from "simple-git";
+import { promises as fs } from "fs";
+import path from "path";
+import fg from "fast-glob";
+var DocsManager = class {
+  git;
+  repoPath;
+  contentPath;
+  fileCache = /* @__PURE__ */ new Map();
+  constructor() {
+    this.repoPath = path.resolve(activeConfig.repo.localPath);
+    this.contentPath = path.join(this.repoPath, activeConfig.repo.contentPath);
+    this.git = simpleGit();
+  }
+  /**
+   * Initialize the docs manager
+   * Checks if repo exists, clones if needed
+   */
+  async initialize() {
+    const repoExists = await this.checkRepoExists();
+    if (!repoExists) {
+      console.log("Cloning React documentation repository...");
+      await this.cloneRepo();
+      console.log("Repository cloned successfully");
+    } else {
+      console.log("Repository already exists");
+    }
+  }
+  /**
+   * Check if repository exists locally
+   */
+  async checkRepoExists() {
+    try {
+      await fs.access(path.join(this.repoPath, ".git"));
+      return true;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Clone the repository
+   */
+  async cloneRepo() {
+    try {
+      await fs.mkdir(path.dirname(this.repoPath), { recursive: true });
+      await this.git.clone(activeConfig.repo.url, this.repoPath, {
+        "--depth": 1
+        // Shallow clone for faster download
+      });
+    } catch (error) {
+      throw new Error(
+        `Failed to clone repository: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Get repository status
+   */
+  async getStatus() {
+    const isCloned = await this.checkRepoExists();
+    if (!isCloned) {
+      return { isCloned: false };
+    }
+    try {
+      const git = simpleGit(this.repoPath);
+      const log = await git.log({ maxCount: 1 });
+      return {
+        isCloned: true,
+        currentCommit: log.latest?.hash,
+        lastUpdated: log.latest?.date ? new Date(log.latest.date) : void 0
+      };
+    } catch (error) {
+      console.error("Failed to get repo status:", error);
+      return { isCloned: true };
+    }
+  }
+  /**
+   * Update repository (git pull)
+   * Returns true if updates were pulled
+   */
+  async updateRepo() {
+    const isCloned = await this.checkRepoExists();
+    if (!isCloned) {
+      throw new Error("Repository not cloned. Call initialize() first.");
+    }
+    try {
+      const git = simpleGit(this.repoPath);
+      const beforeHash = await git.revparse(["HEAD"]);
+      await git.pull();
+      const afterHash = await git.revparse(["HEAD"]);
+      const hasUpdates = beforeHash !== afterHash;
+      if (hasUpdates) {
+        this.fileCache.clear();
+        console.log("Repository updated successfully");
+      } else {
+        console.log("Repository already up to date");
+      }
+      return hasUpdates;
+    } catch (error) {
+      throw new Error(
+        `Failed to update repository: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Get all markdown files from a section
+   * @param section - Section name (learn, reference, etc.)
+   * @returns Array of file paths relative to content root
+   */
+  async getDocsInSection(section) {
+    const cacheKey = `section:${section}`;
+    if (this.fileCache.has(cacheKey)) {
+      return this.fileCache.get(cacheKey);
+    }
+    const sectionPath = path.join(this.contentPath, section);
+    try {
+      await fs.access(sectionPath);
+    } catch {
+      return [];
+    }
+    const files = await fg(["**/*.md", "**/*.mdx"], {
+      cwd: sectionPath,
+      absolute: false,
+      ignore: ["**/_*.md", "**/_*.mdx"]
+    });
+    const relativePaths = files.map((file) => `${section}/${file}`);
+    this.fileCache.set(cacheKey, relativePaths);
+    return relativePaths;
+  }
+  /**
+   * Get all markdown files across all sections
+   * @returns Array of file paths relative to content root
+   */
+  async getAllDocs() {
+    const cacheKey = "all";
+    if (this.fileCache.has(cacheKey)) {
+      return this.fileCache.get(cacheKey);
+    }
+    const files = await fg(["**/*.md", "**/*.mdx"], {
+      cwd: this.contentPath,
+      absolute: false,
+      ignore: ["**/_*.md", "**/_*.mdx"]
+    });
+    this.fileCache.set(cacheKey, files);
+    return files;
+  }
+  /**
+   * Read file content
+   * @param relativePath - Path relative to content root
+   * @returns Raw file content
+   */
+  async readDoc(relativePath) {
+    const fullPath = path.join(this.contentPath, relativePath);
+    try {
+      return await fs.readFile(fullPath, "utf-8");
+    } catch (error) {
+      throw new Error(
+        `Failed to read document at ${relativePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+    }
+  }
+  /**
+   * Check if file exists
+   * @param relativePath - Path relative to content root
+   */
+  async docExists(relativePath) {
+    const fullPath = path.join(this.contentPath, relativePath);
+    try {
+      await fs.access(fullPath);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+};
+
+// ../../src/markdownParser.ts
+import matter from "gray-matter";
+import { remark } from "remark";
+import stripMarkdown from "strip-markdown";
+async function parseMarkdown(content, path2) {
+  const { data, content: markdownContent } = matter(content);
+  const metadata = {
+    title: data.title || extractTitleFromPath(path2),
+    description: data.description,
+    date: data.date,
+    author: data.author,
+    tags: data.tags,
+    ...data
+  };
+  const plainText = await markdownToPlainText(markdownContent);
+  const section = extractSection(path2);
+  return {
+    path: normalizePath(path2),
+    section,
+    metadata,
+    content: markdownContent,
+    plainText
+  };
+}
+async function markdownToPlainText(markdown) {
+  const result = await remark().use(stripMarkdown).process(markdown);
+  return String(result).replace(/\s+/g, " ").trim();
+}
+function extractSection(path2) {
+  const normalized = normalizePath(path2);
+  const parts = normalized.split("/");
+  return parts[0] || "unknown";
+}
+function normalizePath(filePath) {
+  return filePath.replace(/\\/g, "/").replace(/^\/+/, "").replace(/\.mdx?$/, "");
+}
+function extractTitleFromPath(filePath) {
+  const normalized = normalizePath(filePath);
+  const parts = normalized.split("/");
+  const filename = parts[parts.length - 1] || "Untitled";
+  return filename.replace(/[-_]/g, " ").split(" ").map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+
+// ../../src/embeddingService.ts
+import { pipeline, env } from "@xenova/transformers";
+env.allowLocalModels = true;
+env.allowRemoteModels = true;
+var EmbeddingService = class {
+  pipeline = null;
+  initialized = false;
+  modelName = "Xenova/all-MiniLM-L6-v2";
+  /**
+   * Initialize the embedding pipeline
+   * Downloads model on first run (~23MB)
+   */
+  async initialize() {
+    if (this.initialized) return;
+    console.log("Initializing embedding model (first run may take a moment)...");
+    try {
+      this.pipeline = await pipeline("feature-extraction", this.modelName);
+      this.initialized = true;
+      console.log("Embedding model initialized successfully");
+    } catch (error) {
+      console.error("Failed to initialize embedding model:", error);
+      throw new Error(`Embedding initialization failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Generate embedding for a text
+   * @param text - Text to embed
+   * @returns Vector embedding (384 dimensions for all-MiniLM-L6-v2)
+   */
+  async generateEmbedding(text) {
+    if (!this.initialized) {
+      await this.initialize();
+    }
+    try {
+      const truncated = text.slice(0, 2e3);
+      const output = await this.pipeline(truncated, {
+        pooling: "mean",
+        normalize: true
+      });
+      const embedding = Array.from(output.data);
+      return embedding;
+    } catch (error) {
+      console.error("Failed to generate embedding:", error);
+      throw new Error(`Embedding generation failed: ${error instanceof Error ? error.message : String(error)}`);
+    }
+  }
+  /**
+   * Generate embeddings for multiple texts (batch processing)
+   * @param texts - Array of texts to embed
+   * @returns Array of vector embeddings
+   */
+  async generateEmbeddings(texts) {
+    const embeddings = [];
+    for (const text of texts) {
+      const embedding = await this.generateEmbedding(text);
+      embeddings.push(embedding);
+    }
+    return embeddings;
+  }
+  /**
+   * Calculate cosine similarity between two vectors
+   * @param a - First vector
+   * @param b - Second vector
+   * @returns Similarity score (0-1, higher is more similar)
+   */
+  cosineSimilarity(a, b) {
+    if (a.length !== b.length) {
+      throw new Error("Vectors must have same length");
+    }
+    let dotProduct = 0;
+    let normA = 0;
+    let normB = 0;
+    for (let i = 0; i < a.length; i++) {
+      dotProduct += a[i] * b[i];
+      normA += a[i] * a[i];
+      normB += b[i] * b[i];
+    }
+    const magnitude = Math.sqrt(normA) * Math.sqrt(normB);
+    if (magnitude === 0) return 0;
+    return dotProduct / magnitude;
+  }
+  /**
+   * Find most similar vectors to a query vector
+   * @param queryEmbedding - Query vector
+   * @param docEmbeddings - Array of document vectors with metadata
+   * @param topK - Number of results to return
+   * @returns Array of {index, similarity} sorted by similarity desc
+   */
+  findMostSimilar(queryEmbedding, docEmbeddings, topK) {
+    const similarities = docEmbeddings.map(({ embedding, index }) => ({
+      index,
+      similarity: this.cosineSimilarity(queryEmbedding, embedding)
+    }));
+    similarities.sort((a, b) => b.similarity - a.similarity);
+    return similarities.slice(0, topK);
+  }
+};
+
+// ../../src/searchEngine.ts
+var SearchEngine = class {
+  docsManager;
+  embeddingService;
+  documentIndex = /* @__PURE__ */ new Map();
+  indexed = false;
+  embeddingsGenerated = false;
+  /**
+   * Initialize search engine
+   * @param docsManager - Instance of DocsManager
+   */
+  constructor(docsManager) {
+    this.docsManager = docsManager;
+    this.embeddingService = new EmbeddingService();
+  }
+  /**
+   * Index all documents for searching
+   * Should be called after repo update
+   */
+  async indexDocuments() {
+    console.log("Indexing documents...");
+    this.documentIndex.clear();
+    const allDocs = await this.docsManager.getAllDocs();
+    for (const docPath of allDocs) {
+      try {
+        const content = await this.docsManager.readDoc(docPath);
+        const parsedDoc = await parseMarkdown(content, docPath);
+        this.documentIndex.set(parsedDoc.path, parsedDoc);
+      } catch (error) {
+        console.warn(`Failed to index document ${docPath}:`, error);
+      }
+    }
+    this.indexed = true;
+    console.log(`Indexed ${this.documentIndex.size} documents`);
+  }
+  /**
+   * Generate embeddings for all documents
+   * Called lazily when semantic search is first used
+   */
+  async generateEmbeddings() {
+    if (this.embeddingsGenerated) return;
+    console.log("Generating embeddings for documents (first run may take 1-2 minutes)...");
+    try {
+      await this.embeddingService.initialize();
+      let count = 0;
+      for (const doc of this.documentIndex.values()) {
+        const embeddingText = `${doc.metadata.title}. ${doc.metadata.description || ""}. ${doc.plainText.slice(0, 1e3)}`;
+        const embedding = await this.embeddingService.generateEmbedding(embeddingText);
+        doc.embedding = embedding;
+        count++;
+        if (count % 10 === 0) {
+          console.log(`Generated embeddings for ${count}/${this.documentIndex.size} documents...`);
+        }
+      }
+      this.embeddingsGenerated = true;
+      console.log(`Embeddings generated for all ${this.documentIndex.size} documents`);
+    } catch (error) {
+      console.error("Failed to generate embeddings:", error);
+      throw error;
+    }
+  }
+  /**
+   * Search documents
+   * @param query - Search query string
+   * @param options - Search options (section filter, limit, etc.)
+   * @returns Ranked search results
+   */
+  async search(query, options) {
+    if (!this.indexed) {
+      await this.indexDocuments();
+    }
+    if (!query.trim()) {
+      return [];
+    }
+    const useSemanticSearch = options?.useSemanticSearch ?? activeConfig.search.semanticSearchEnabled;
+    if (useSemanticSearch) {
+      return await this.semanticSearch(query, options);
+    }
+    return await this.keywordSearch(query, options);
+  }
+  /**
+   * Keyword-based search
+   */
+  async keywordSearch(query, options) {
+    const limit = Math.min(
+      options?.limit || activeConfig.search.defaultLimit,
+      activeConfig.search.maxLimit
+    );
+    const minScore = options?.minScore ?? activeConfig.search.minScore;
+    const sectionFilter = options?.section?.toLowerCase();
+    const queryTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const results = [];
+    for (const doc of this.documentIndex.values()) {
+      if (sectionFilter && doc.section.toLowerCase() !== sectionFilter) {
+        continue;
+      }
+      const score = this.scoreDocument(doc, queryTerms);
+      if (score >= minScore) {
+        const snippet = this.generateSnippet(doc, queryTerms);
+        results.push({ doc, score, snippet });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+  }
+  /**
+   * Semantic search using embeddings (hybrid with keyword search)
+   */
+  async semanticSearch(query, options) {
+    if (!this.embeddingsGenerated) {
+      await this.generateEmbeddings();
+    }
+    const limit = Math.min(
+      options?.limit || activeConfig.search.defaultLimit,
+      activeConfig.search.maxLimit
+    );
+    const sectionFilter = options?.section?.toLowerCase();
+    const queryEmbedding = await this.embeddingService.generateEmbedding(query);
+    const docs = Array.from(this.documentIndex.values()).filter((doc) => {
+      if (sectionFilter && doc.section.toLowerCase() !== sectionFilter) {
+        return false;
+      }
+      return doc.embedding !== void 0;
+    });
+    const queryTerms = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const results = [];
+    for (const doc of docs) {
+      const keywordScore = this.scoreDocument(doc, queryTerms) / 100;
+      const semanticScore = this.embeddingService.cosineSimilarity(
+        queryEmbedding,
+        doc.embedding
+      );
+      const hybridScore = activeConfig.search.hybridKeywordWeight * keywordScore + activeConfig.search.hybridSemanticWeight * semanticScore;
+      if (semanticScore >= activeConfig.search.semanticMinSimilarity) {
+        const snippet = this.generateSnippet(doc, queryTerms);
+        results.push({ doc, score: hybridScore, snippet });
+      }
+    }
+    results.sort((a, b) => b.score - a.score);
+    return results.slice(0, limit);
+  }
+  /**
+   * Score a document based on query terms
+   */
+  scoreDocument(doc, queryTerms) {
+    let score = 0;
+    const titleLower = doc.metadata.title.toLowerCase();
+    const plainTextLower = doc.plainText.toLowerCase();
+    const pathLower = doc.path.toLowerCase();
+    for (const term of queryTerms) {
+      if (titleLower.includes(term)) {
+        score += 10;
+      }
+      if (pathLower.includes(term)) {
+        score += 5;
+      }
+      const regex = new RegExp(term, "gi");
+      const matches = plainTextLower.match(regex);
+      if (matches) {
+        score += matches.length * 0.5;
+      }
+      if (doc.metadata.description?.toLowerCase().includes(term)) {
+        score += 3;
+      }
+    }
+    return score;
+  }
+  /**
+   * Generate context snippet showing matched text
+   */
+  generateSnippet(doc, queryTerms) {
+    const plainText = doc.plainText;
+    let firstMatchIndex = -1;
+    let matchedTerm = "";
+    for (const term of queryTerms) {
+      const index = plainText.toLowerCase().indexOf(term);
+      if (index !== -1 && (firstMatchIndex === -1 || index < firstMatchIndex)) {
+        firstMatchIndex = index;
+        matchedTerm = term;
+      }
+    }
+    if (firstMatchIndex === -1) {
+      return doc.metadata.description || plainText.slice(0, 150) + "...";
+    }
+    const contextRadius = 75;
+    const start = Math.max(0, firstMatchIndex - contextRadius);
+    const end = Math.min(plainText.length, firstMatchIndex + matchedTerm.length + contextRadius);
+    let snippet = plainText.slice(start, end);
+    if (start > 0) snippet = "..." + snippet;
+    if (end < plainText.length) snippet = snippet + "...";
+    return snippet.trim();
+  }
+  /**
+   * Get document by exact path
+   * @param path - Document path relative to content root
+   * @returns Parsed document or null if not found
+   */
+  async getDocByPath(path2) {
+    if (!this.indexed) {
+      await this.indexDocuments();
+    }
+    const normalizedPath = path2.replace(/\.mdx?$/, "");
+    return this.documentIndex.get(normalizedPath) || null;
+  }
+  /**
+   * List all available sections
+   */
+  getSections() {
+    return [...activeConfig.sections];
+  }
+  /**
+   * Get all documents in a section
+   */
+  async getDocsBySection(section) {
+    if (!this.indexed) {
+      await this.indexDocuments();
+    }
+    const sectionLower = section.toLowerCase();
+    const docs = [];
+    for (const doc of this.documentIndex.values()) {
+      if (doc.section.toLowerCase() === sectionLower) {
+        docs.push(doc);
+      }
+    }
+    return docs;
+  }
+};
+
+// ../../src/summarizer.ts
+function summarizeContent(content, maxLength = 1500) {
+  let summary = content.replace(/```[\s\S]*?```/g, "");
+  summary = summary.replace(/^---[\s\S]*?---\n/, "");
+  const paragraphs = summary.split(/\n\n+/).map((p) => p.trim()).filter((p) => p.length > 0 && !p.startsWith("#"));
+  let result = "";
+  let headings = [];
+  const headingMatches = content.match(/^#{1,3}\s+(.+)$/gm);
+  if (headingMatches) {
+    headings = headingMatches.slice(0, 5).map((h) => h.replace(/^#+\s*/, "- "));
+  }
+  for (const para of paragraphs.slice(0, 3)) {
+    result += para + "\n\n";
+  }
+  if (headings.length > 0 && result.length < maxLength * 0.7) {
+    result += "\n**Content structure:**\n" + headings.join("\n");
+  }
+  if (result.length > maxLength) {
+    result = result.slice(0, maxLength) + "...";
+  }
+  return result.trim();
+}
+function extractStructure(content) {
+  const lines = content.split("\n");
+  const structure = [];
+  let currentHeading = "";
+  let capturedFirstLine = false;
+  for (const line of lines) {
+    const headingMatch = line.match(/^(#{1,3})\s+(.+)$/);
+    if (headingMatch) {
+      currentHeading = headingMatch[2];
+      structure.push(`
+**${currentHeading}**`);
+      capturedFirstLine = false;
+      continue;
+    }
+    if (currentHeading && !capturedFirstLine && line.trim().length > 20) {
+      const cleaned = line.replace(/[*_`]/g, "").trim();
+      if (!cleaned.startsWith("<") && !cleaned.startsWith("[")) {
+        structure.push(cleaned.slice(0, 100));
+        capturedFirstLine = true;
+      }
+    }
+  }
+  return structure.join("\n");
+}
+
+// ../../src/server.ts
+function titleCase(section) {
+  return section.split(/[-_]/).map((word) => word.charAt(0).toUpperCase() + word.slice(1)).join(" ");
+}
+function buildDocUrl(doc) {
+  let slug = doc.path;
+  const id = doc.metadata.id;
+  if (activeConfig.docUrl.useFrontmatterId && id) {
+    if (id.includes("/")) {
+      slug = id;
+    } else {
+      const parts = doc.path.split("/");
+      parts[parts.length - 1] = id;
+      slug = parts.join("/");
+    }
+  }
+  return `${activeConfig.docUrl.base}/${slug}`;
+}
+async function createServer() {
+  const docsManager = new DocsManager();
+  const searchEngine = new SearchEngine(docsManager);
+  const server = new Server(
+    {
+      name: activeConfig.server.name,
+      version: activeConfig.server.version
+    },
+    {
+      capabilities: {
+        resources: {},
+        tools: {}
+      }
+    }
+  );
+  const searchDocsSchema = z.object({
+    query: z.string().describe("Search query string"),
+    section: z.string().optional().describe(`Filter by section (${activeConfig.sections.join(", ")})`),
+    limit: z.number().min(1).max(activeConfig.search.maxLimit).optional().describe("Maximum number of results")
+  });
+  const getDocSchema = z.object({
+    path: z.string().describe('Document path (e.g., "learn/hooks/useState")')
+  });
+  const resourceUriRegex = new RegExp(`^${activeConfig.resourceUriScheme}:\\/\\/(.+)$`);
+  server.setRequestHandler(ListResourcesRequestSchema, async () => {
+    return {
+      resources: activeConfig.sections.map((section) => {
+        const override = activeConfig.sectionResourceOverrides?.[section];
+        return {
+          uri: `${activeConfig.resourceUriScheme}://${section}`,
+          name: override?.name ?? `${activeConfig.docsLabel} ${titleCase(section)} Documentation`,
+          description: override?.description ?? `${activeConfig.docsLabel} documentation for the ${section} section`,
+          mimeType: "text/plain"
+        };
+      })
+    };
+  });
+  server.setRequestHandler(ReadResourceRequestSchema, async (request) => {
+    const uri = request.params.uri.toString();
+    const match = uri.match(resourceUriRegex);
+    if (!match) {
+      throw new Error(`Invalid resource URI: ${uri}`);
+    }
+    const resourcePath = match[1];
+    if (activeConfig.sections.includes(resourcePath)) {
+      const docs = await searchEngine.getDocsBySection(resourcePath);
+      const docList = docs.map((doc2) => `- ${doc2.metadata.title} (${doc2.path})`).join("\n");
+      return {
+        contents: [
+          {
+            uri,
+            mimeType: "text/plain",
+            text: `# ${resourcePath} Documentation
+
+Available documents:
+
+${docList}`
+          }
+        ]
+      };
+    }
+    const doc = await searchEngine.getDocByPath(resourcePath);
+    if (!doc) {
+      throw new Error(`Document not found: ${resourcePath}`);
+    }
+    return {
+      contents: [
+        {
+          uri,
+          mimeType: "text/markdown",
+          text: `# ${doc.metadata.title}
+
+${doc.content}`
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+      tools: [
+        {
+          name: activeConfig.searchToolName,
+          description: activeConfig.searchToolDescription,
+          inputSchema: {
+            type: "object",
+            properties: {
+              query: {
+                type: "string",
+                description: "Search query string"
+              },
+              section: {
+                type: "string",
+                description: `Filter by section (${activeConfig.sections.join(", ")})`,
+                enum: [...activeConfig.sections]
+              },
+              limit: {
+                type: "number",
+                description: "Maximum number of results",
+                minimum: 1,
+                maximum: activeConfig.search.maxLimit
+              }
+            },
+            required: ["query"]
+          }
+        },
+        {
+          name: "list_sections",
+          description: "List all available documentation sections",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        },
+        {
+          name: "get_doc",
+          description: `Get a concise summary of a documentation page (~1500 chars). Use ${activeConfig.searchToolName} first - only call this if you need more detail than the search snippet provides.`,
+          inputSchema: {
+            type: "object",
+            properties: {
+              path: {
+                type: "string",
+                description: 'Document path (e.g., "learn/hooks/useState")'
+              }
+            },
+            required: ["path"]
+          }
+        },
+        {
+          name: "update_docs",
+          description: "Pull latest documentation from Git repository",
+          inputSchema: {
+            type: "object",
+            properties: {}
+          }
+        }
+      ]
+    };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const { name, arguments: args } = request.params;
+    try {
+      switch (name) {
+        case activeConfig.searchToolName: {
+          const { query, section, limit } = searchDocsSchema.parse(args);
+          const results = await searchEngine.search(query, { section, limit });
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  results.map((r) => ({
+                    path: r.doc.path,
+                    title: r.doc.metadata.title,
+                    snippet: r.snippet,
+                    score: r.score,
+                    url: buildDocUrl(r.doc)
+                  })),
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        }
+        case "list_sections": {
+          const sections = searchEngine.getSections();
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(sections, null, 2)
+              }
+            ]
+          };
+        }
+        case "get_doc": {
+          const { path: path2 } = getDocSchema.parse(args);
+          const doc = await searchEngine.getDocByPath(path2);
+          if (!doc) {
+            throw new Error(`Document not found: ${path2}`);
+          }
+          const summary = summarizeContent(doc.content, 1500);
+          const structure = extractStructure(doc.content);
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    path: doc.path,
+                    section: doc.section,
+                    title: doc.metadata.title,
+                    description: doc.metadata.description,
+                    summary,
+                    structure,
+                    url: buildDocUrl(doc),
+                    note: "This is a summary. Visit the URL for full documentation."
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        }
+        case "update_docs": {
+          const updated = await docsManager.updateRepo();
+          if (updated) {
+            await searchEngine.indexDocuments();
+          }
+          return {
+            content: [
+              {
+                type: "text",
+                text: JSON.stringify(
+                  {
+                    updated,
+                    message: updated ? "Documentation updated successfully" : "Documentation already up to date"
+                  },
+                  null,
+                  2
+                )
+              }
+            ]
+          };
+        }
+        default:
+          throw new Error(`Unknown tool: ${name}`);
+      }
+    } catch (error) {
+      if (error instanceof z.ZodError) {
+        throw new Error(`Invalid arguments: ${error.message}`);
+      }
+      throw error;
+    }
+  });
+  console.error(`Initializing ${activeConfig.docsLabel} Docs MCP Server...`);
+  await docsManager.initialize();
+  const transport = new StdioServerTransport();
+  await server.connect(transport);
+  console.error(`${activeConfig.docsLabel} Docs MCP Server running`);
+}
+
+// src/index.ts
+configure(reactNativeDocsPreset);
+createServer().catch((error) => {
+  console.error("Failed to start server:", error);
+  process.exit(1);
+});

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "react-native-docs-mcp",
+  "version": "0.1.0",
+  "description": "MCP server providing AI agents with semantic search over React Native documentation",
+  "main": "dist/index.js",
+  "type": "module",
+  "bin": {
+    "react-native-docs-mcp": "dist/index.js"
+  },
+  "scripts": {
+    "build": "tsup src/index.ts --format esm --platform node --target node18 --out-dir dist --clean",
+    "dev": "tsx src/index.ts",
+    "start": "node dist/index.js",
+    "prepublishOnly": "npm run build"
+  },
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "react-native",
+    "react-native-docs",
+    "documentation",
+    "ai",
+    "claude",
+    "cursor",
+    "semantic-search",
+    "embeddings",
+    "vector-search"
+  ],
+  "author": "sannnao",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Sannnao/react-docs-mcp.git",
+    "directory": "packages/react-native-docs-mcp"
+  },
+  "homepage": "https://github.com/Sannnao/react-docs-mcp/tree/master/packages/react-native-docs-mcp#readme",
+  "bugs": {
+    "url": "https://github.com/Sannnao/react-docs-mcp/issues"
+  },
+  "engines": {
+    "node": ">=18.0.0"
+  },
+  "files": [
+    "dist/**/*.js",
+    "dist/**/*.js.map",
+    "README.md"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.20.0",
+    "@xenova/transformers": "^2.17.2",
+    "fast-glob": "^3.3.3",
+    "gray-matter": "^4.0.3",
+    "remark": "^15.0.1",
+    "simple-git": "^3.28.0",
+    "strip-markdown": "^6.0.0",
+    "zod": "^3.25.76"
+  },
+  "devDependencies": {
+    "tsup": "^8.5.0",
+    "tsx": "^4.20.6",
+    "typescript": "^5.9.3"
+  }
+}