feathersjs-docs-mcp 0.1.0

package/README.md

@@ -0,0 +1,102 @@
+# feathersjs-docs-mcp
+
+Read-only MCP server for discovering and reading **FeathersJS documentation** from the official Feathers repository.
+
+---
+
+## Features
+
+- Syncs the Feathers docs repository into a local cache
+- Indexes markdown pages from `docs/`
+- Exposes MCP tools for listing, reading, refreshing, and status checks
+- Exposes `feathers-doc://docs/{path}` as a markdown resource template
+
+## MCP Tools
+
+- `list_docs(query?, limit?, offset?)`
+- `read_doc(uri)`
+- `refresh_docs_index(forceRebuild?)`
+- `get_docs_status()`
+
+---
+
+## Installation
+
+```bash
+npm install
+```
+
+## Build
+
+```bash
+npm run build
+```
+
+## Run
+
+```bash
+npm start
+```
+
+### Run with explicit transport
+
+`feathersjs-docs-mcp` does not auto-detect transport at runtime. Set transport explicitly:
+
+```bash
+# Default standalone streamable HTTP transport for shared localhost access
+npm start
+
+# Explicitly force stdio transport
+FEATHERS_MCP_TRANSPORT=stdio npm start
+```
+
+When running with `httpStream`:
+
+- MCP streamable HTTP endpoint: `http://127.0.0.1:8123/mcp` (customizable)
+- SSE compatibility endpoint: `http://127.0.0.1:8123/sse` (provided by FastMCP)
+
+## Test
+
+```bash
+npm run test:e2e
+```
+
+---
+
+## Configuration
+
+- `FEATHERS_MCP_TRANSPORT` (default: `httpStream`, values: `stdio` | `httpStream`)
+- `FEATHERS_MCP_HTTP_HOST` (default: `127.0.0.1`)
+- `FEATHERS_MCP_HTTP_PORT` (default: `8123`)
+- `FEATHERS_MCP_HTTP_ENDPOINT` (default: `/mcp`)
+- `FEATHERS_MCP_HTTP_STATELESS` (default: `false`)
+- `FEATHERS_REPO_URL` (default: `https://github.com/feathersjs/feathers.git`)
+- `FEATHERS_REPO_BRANCH` (default: `dove`)
+- `FEATHERS_MCP_CACHE_DIR` (default: `./.cache/feathersjs-docs-mcp`)
+- `TOP_K` (default: `6`)
+
+---
+
+## Example MCP client config
+
+```json
+{
+  "mcpServers": {
+    "feathers-docs": {
+      "command": "node",
+      "args": ["/home/bob/feathersjs-docs-mcp/dist/index.js"],
+      "disabled": false,
+      "autoApprove": [],
+      "env": {
+        "FEATHERS_REPO_BRANCH": "dove"
+      }
+    }
+  }
+}
+```
+
+---
+
+## License
+
+MIT

package/dist/config.js

@@ -0,0 +1,72 @@
+import path from 'node:path';
+/**
+ * Parse an integer from an environment variable with fallback handling.
+ */
+function intFromEnv(name, fallback) {
+    const value = process.env[name];
+    if (!value)
+        return fallback;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : fallback;
+}
+/**
+ * Parse a boolean from an environment variable with fallback handling.
+ */
+function boolFromEnv(name, fallback) {
+    const value = process.env[name];
+    if (!value)
+        return fallback;
+    const normalized = value.toLowerCase().trim();
+    if (normalized === 'true' || normalized === '1' || normalized === 'yes')
+        return true;
+    if (normalized === 'false' || normalized === '0' || normalized === 'no')
+        return false;
+    return fallback;
+}
+/**
+ * Parse MCP transport mode from environment.
+ */
+function transportFromEnv() {
+    const value = process.env.FEATHERS_MCP_TRANSPORT;
+    if (!value)
+        return 'httpStream';
+    if (value === 'stdio' || value === 'httpStream')
+        return value;
+    throw new Error(`Invalid FEATHERS_MCP_TRANSPORT: "${value}". Expected "stdio" or "httpStream".`);
+}
+/**
+ * Parse and normalize MCP endpoint path.
+ */
+function endpointFromEnv() {
+    const value = process.env.FEATHERS_MCP_HTTP_ENDPOINT;
+    if (!value)
+        return '/mcp';
+    const trimmed = value.trim();
+    if (!trimmed.startsWith('/')) {
+        throw new Error(`Invalid FEATHERS_MCP_HTTP_ENDPOINT: "${value}". Expected path starting with "/".`);
+    }
+    return trimmed;
+}
+/**
+ * Build the application configuration from environment variables.
+ */
+export function getConfig() {
+    const baseCache = process.env.FEATHERS_MCP_CACHE_DIR
+        ? path.resolve(process.env.FEATHERS_MCP_CACHE_DIR)
+        : path.resolve(process.cwd(), '.cache', 'feathersjs-docs-mcp');
+    const repoDir = path.join(baseCache, 'feathers-repo');
+    const docsDir = path.join(repoDir, 'docs');
+    return {
+        transport: transportFromEnv(),
+        repoUrl: process.env.FEATHERS_REPO_URL ?? 'https://github.com/feathersjs/feathers.git',
+        repoBranch: process.env.FEATHERS_REPO_BRANCH ?? 'dove',
+        cacheDir: baseCache,
+        repoDir,
+        docsDir,
+        topK: intFromEnv('TOP_K', 6),
+        httpHost: process.env.FEATHERS_MCP_HTTP_HOST ?? '127.0.0.1',
+        httpPort: intFromEnv('FEATHERS_MCP_HTTP_PORT', 8123),
+        httpEndpoint: endpointFromEnv(),
+        httpStateless: boolFromEnv('FEATHERS_MCP_HTTP_STATELESS', false)
+    };
+}

package/dist/docs/discover.js

@@ -0,0 +1,28 @@
+import fs from 'node:fs';
+import path from 'node:path';
+/**
+ * Recursively walk a directory and collect markdown files.
+ */
+function walk(dir, out) {
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const full = path.join(dir, entry.name);
+        if (entry.isDirectory()) {
+            walk(full, out);
+            continue;
+        }
+        if (entry.isFile() && entry.name.endsWith('.md')) {
+            out.push(full);
+        }
+    }
+}
+/**
+ * Discover all markdown pages under the provided docs directory.
+ */
+export function discoverMarkdownFiles(docsDir) {
+    if (!fs.existsSync(docsDir))
+        return [];
+    const files = [];
+    walk(docsDir, files);
+    return files.sort();
+}

package/dist/docs/parse.js

@@ -0,0 +1,38 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import matter from 'gray-matter';
+import { sha256, toUri } from '../utils.js';
+/**
+ * Extract markdown headings from body content.
+ */
+function extractHeadings(content) {
+    return content
+        .split('\n')
+        .filter((line) => /^#{1,6}\s+/.test(line))
+        .map((line) => line.replace(/^#{1,6}\s+/, '').trim());
+}
+/**
+ * Parse a markdown file into normalized page metadata used by the index.
+ */
+export function parseMarkdownFile(filePath, docsDir) {
+    const raw = fs.readFileSync(filePath, 'utf8');
+    const stat = fs.statSync(filePath);
+    const relativePath = path.relative(docsDir, filePath);
+    const uri = toUri(relativePath);
+    const parsed = matter(raw);
+    const body = parsed.content.trim();
+    const headings = extractHeadings(body);
+    const title = (typeof parsed.data.title === 'string' ? parsed.data.title : undefined) ??
+        headings[0] ??
+        path.basename(filePath, '.md');
+    const checksum = sha256(raw);
+    const page = {
+        uri,
+        title,
+        relativePath,
+        headings,
+        checksum,
+        lastModified: stat.mtimeMs
+    };
+    return page;
+}

package/dist/docs/sync.js

@@ -0,0 +1,49 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import git from 'isomorphic-git';
+import http from 'isomorphic-git/http/node';
+/**
+ * Ensure Feathers docs repository exists locally and is updated to target branch.
+ *
+ * If repository does not exist, it performs a shallow clone.
+ * Otherwise, it fetches and hard-resets to `origin/<branch>`.
+ */
+export async function syncDocsRepo(config) {
+    fs.mkdirSync(config.cacheDir, { recursive: true });
+    const gitDir = path.join(config.repoDir, '.git');
+    if (!fs.existsSync(gitDir)) {
+        await git.clone({
+            fs,
+            http,
+            dir: config.repoDir,
+            url: config.repoUrl,
+            ref: config.repoBranch,
+            singleBranch: true,
+            depth: 1
+        });
+        const commit = await git.resolveRef({ fs, dir: config.repoDir, ref: 'HEAD' });
+        return { commit, changed: true };
+    }
+    const before = await git.resolveRef({ fs, dir: config.repoDir, ref: 'HEAD' }).catch(() => '');
+    await git.fetch({
+        fs,
+        http,
+        dir: config.repoDir,
+        url: config.repoUrl,
+        ref: config.repoBranch,
+        singleBranch: true,
+        depth: 1,
+        prune: true,
+        tags: false
+    });
+    const remoteRef = `refs/remotes/origin/${config.repoBranch}`;
+    const remoteOid = await git.resolveRef({ fs, dir: config.repoDir, ref: remoteRef });
+    await git.checkout({
+        fs,
+        dir: config.repoDir,
+        ref: remoteOid,
+        force: true
+    });
+    const after = await git.resolveRef({ fs, dir: config.repoDir, ref: 'HEAD' });
+    return { commit: after, changed: before !== after };
+}

package/dist/index.js

@@ -0,0 +1,218 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import { FastMCP } from 'fastmcp';
+import { z } from 'zod';
+import { getConfig } from './config.js';
+import { syncDocsRepo } from './docs/sync.js';
+import { discoverMarkdownFiles } from './docs/discover.js';
+import { parseMarkdownFile } from './docs/parse.js';
+const listDocsParams = z.object({
+    query: z.string().optional(),
+    limit: z.number().int().min(1).max(20).optional(),
+    offset: z.number().int().min(0).optional()
+});
+const readDocParams = z.object({
+    uri: z.string().startsWith('feathers-doc://docs/')
+});
+const refreshDocsParams = z.object({
+    forceRebuild: z.boolean().optional()
+});
+/** Global runtime configuration loaded from environment variables. */
+const config = getConfig();
+/** Timestamp of the last successful refresh cycle. */
+let lastSyncAt = new Date().toISOString();
+/** Latest commit hash from synchronized docs repository. */
+let commit = '';
+/** In-memory docs page index used by MCP tools. */
+let pages = [];
+/** Effective docs directory resolved at runtime. */
+let docsDirResolved = config.docsDir;
+/** Non-fatal issues discovered while resolving/discovering docs. */
+let discoveryWarnings = [];
+/**
+ * Resolve the docs directory and update discovery warnings if missing.
+ */
+function resolveDocsDir() {
+    if (!fs.existsSync(config.docsDir)) {
+        discoveryWarnings = [`Docs directory not found: ${config.docsDir}`];
+        return config.docsDir;
+    }
+    discoveryWarnings = [];
+    return config.docsDir;
+}
+/**
+ * Convert a docs URI into an absolute file path with traversal protection.
+ */
+function resolveDocFilePath(docsDir, uri) {
+    const prefix = 'feathers-doc://docs/';
+    if (!uri.startsWith(prefix)) {
+        throw new Error(`Invalid URI: ${uri}`);
+    }
+    const relativePath = decodeURIComponent(uri.slice(prefix.length));
+    const resolved = path.resolve(docsDir, relativePath);
+    const root = path.resolve(docsDir);
+    if (!resolved.startsWith(root)) {
+        throw new Error('Path traversal detected');
+    }
+    return resolved;
+}
+/**
+ * Synchronize docs repository and rebuild in-memory metadata index.
+ */
+async function refreshDocs() {
+    const sync = await syncDocsRepo(config);
+    commit = sync.commit;
+    docsDirResolved = resolveDocsDir();
+    const files = discoverMarkdownFiles(docsDirResolved);
+    pages = files.map((file) => parseMarkdownFile(file, docsDirResolved));
+    if (files.length === 0) {
+        discoveryWarnings.push(`No markdown pages found under: ${docsDirResolved}`);
+    }
+    lastSyncAt = new Date().toISOString();
+}
+await refreshDocs();
+/** FastMCP server instance configured for stdio transport. */
+const server = new FastMCP({
+    name: 'feathersjs-docs-mcp',
+    version: '0.1.0'
+});
+server.addResourceTemplate({
+    uriTemplate: 'feathers-doc://docs/{path}',
+    name: 'Feathers Documentation Page',
+    mimeType: 'text/markdown',
+    arguments: [
+        {
+            name: 'path',
+            required: true
+        }
+    ],
+    async load({ path: docPath }) {
+        const filePath = resolveDocFilePath(docsDirResolved, `feathers-doc://docs/${docPath}`);
+        const text = fs.readFileSync(filePath, 'utf8');
+        return {
+            text
+        };
+    }
+});
+server.addTool({
+    name: 'list_docs',
+    description: 'Lists available FeathersJS docs pages with optional text filtering',
+    parameters: listDocsParams,
+    async execute(args) {
+        const { query, limit, offset } = args;
+        // Filter pages by title/path/headings when a query is provided.
+        const q = query?.toLowerCase().trim();
+        const filtered = pages.filter((page) => {
+            if (!q)
+                return true;
+            return (page.title.toLowerCase().includes(q) ||
+                page.relativePath.toLowerCase().includes(q) ||
+                page.headings.some((h) => h.toLowerCase().includes(q)));
+        });
+        // Apply cursor-style pagination over filtered results for the `results` field.
+        const start = offset ?? 0;
+        const size = limit ?? config.topK;
+        const results = filtered.slice(start, start + size).map((page) => ({
+            uri: page.uri,
+            title: page.title,
+            relativePath: page.relativePath,
+            headings: page.headings.slice(0, 8)
+        }));
+        // Build `groups` from the full filtered set (not only paged results)
+        // so clients can render complete section navigation independently of page size.
+        const groupMap = new Map();
+        for (const page of filtered) {
+            const folder = path.posix.dirname(page.relativePath.replaceAll('\\', '/'));
+            const key = folder === '.' ? '/' : folder;
+            const existing = groupMap.get(key) ?? [];
+            existing.push({
+                uri: page.uri,
+                title: page.title,
+                relativePath: page.relativePath,
+                headings: page.headings.slice(0, 8)
+            });
+            groupMap.set(key, existing);
+        }
+        const groups = Array.from(groupMap.entries())
+            .sort((a, b) => a[0].localeCompare(b[0]))
+            .map(([folder, pagesInFolder]) => ({
+            folder,
+            count: pagesInFolder.length,
+            pages: pagesInFolder.sort((a, b) => a.relativePath.localeCompare(b.relativePath))
+        }));
+        // Return a JSON string payload as text content for broad MCP client compatibility.
+        return JSON.stringify({
+            query: query ?? null,
+            total: filtered.length,
+            offset: start,
+            limit: size,
+            count: results.length,
+            results,
+            groups
+        }, null, 2);
+    }
+});
+server.addTool({
+    name: 'read_doc',
+    description: 'Reads a markdown page by feathers-doc URI',
+    parameters: readDocParams,
+    async execute({ uri }) {
+        // Resolve and read the markdown page addressed by the docs URI.
+        const filePath = resolveDocFilePath(docsDirResolved, uri);
+        const text = fs.readFileSync(filePath, 'utf8');
+        return JSON.stringify({ uri, content: text }, null, 2);
+    }
+});
+server.addTool({
+    name: 'refresh_docs_index',
+    description: 'Pull latest Feathers docs and refresh in-memory catalog',
+    parameters: refreshDocsParams,
+    async execute({ forceRebuild }) {
+        // Re-sync repository and fully rebuild in-memory page index.
+        await refreshDocs();
+        return JSON.stringify({
+            ok: true,
+            forceRebuild: forceRebuild ?? false,
+            commit,
+            lastSyncAt,
+            pages: pages.length
+        }, null, 2);
+    }
+});
+server.addTool({
+    name: 'get_docs_status',
+    description: 'Returns repository/index health and metadata',
+    async execute() {
+        // Report current repository/index state for diagnostics.
+        return JSON.stringify({
+            repoUrl: config.repoUrl,
+            branch: config.repoBranch,
+            commit,
+            lastSyncAt,
+            pages: pages.length,
+            docsDirResolved,
+            docsDirExists: fs.existsSync(docsDirResolved),
+            discoveryWarnings,
+            cacheDir: config.cacheDir
+        }, null, 2);
+    }
+});
+if (config.transport === 'stdio') {
+    await server.start({ transportType: 'stdio' });
+    console.error('feathersjs-docs-mcp running on stdio');
+}
+else {
+    await server.start({
+        transportType: 'httpStream',
+        httpStream: {
+            host: config.httpHost,
+            port: config.httpPort,
+            endpoint: config.httpEndpoint,
+            stateless: config.httpStateless
+        }
+    });
+    const protocol = 'http';
+    console.error(`feathersjs-docs-mcp running on ${protocol}://${config.httpHost}:${config.httpPort}${config.httpEndpoint}`);
+    console.error(`feathersjs-docs-mcp SSE compatibility endpoint: ${protocol}://${config.httpHost}:${config.httpPort}/sse`);
+}

package/dist/indexer.js

@@ -0,0 +1,63 @@
+import path from 'node:path';
+import fs from 'node:fs';
+import { discoverMarkdownFiles } from './docs/discover.js';
+import { parseMarkdownFile, toChunkRecord } from './docs/parse.js';
+import { syncDocsRepo } from './docs/sync.js';
+import { createEmbedder } from './search/embed.js';
+import { loadIndexedData, saveIndexedData, VectorStore } from './search/vector-store.js';
+function needsRebuild(existing, commit, config) {
+    if (!existing)
+        return true;
+    return (existing.manifest.commit !== commit ||
+        existing.manifest.embeddingModel !== config.embeddingModel ||
+        existing.manifest.chunkSize !== config.chunkSize ||
+        existing.manifest.chunkOverlap !== config.chunkOverlap);
+}
+export async function buildOrLoadIndex(config, forceRebuild = false) {
+    const sync = syncDocsRepo(config);
+    fs.mkdirSync(config.indexDir, { recursive: true });
+    const embedder = createEmbedder(config.embeddingModel);
+    const store = new VectorStore();
+    const existing = loadIndexedData(config.indexDir);
+    if (!forceRebuild && !sync.changed && !needsRebuild(existing, sync.commit, config) && existing) {
+        store.setData(existing);
+        return { store, embedder, commit: sync.commit, lastSyncAt: new Date().toISOString() };
+    }
+    const files = discoverMarkdownFiles(config.docsDir);
+    const pages = [];
+    const chunkInputs = [];
+    for (const file of files) {
+        const parsed = parseMarkdownFile(file, config.docsDir, config.chunkSize, config.chunkOverlap);
+        pages.push(parsed.page);
+        chunkInputs.push(...parsed.chunks);
+    }
+    const embeddings = await embedder.embed(chunkInputs.map((c) => c.content));
+    const chunks = chunkInputs.map((input, i) => toChunkRecord(input, embeddings[i], config.repoUrl, config.repoBranch, sync.commit));
+    const indexed = {
+        pages,
+        chunks,
+        manifest: {
+            embeddingModel: config.embeddingModel,
+            commit: sync.commit,
+            builtAt: new Date().toISOString(),
+            chunkSize: config.chunkSize,
+            chunkOverlap: config.chunkOverlap
+        }
+    };
+    saveIndexedData(config.indexDir, indexed);
+    store.setData(indexed);
+    return { store, embedder, commit: sync.commit, lastSyncAt: new Date().toISOString() };
+}
+export function resolveDocFilePath(docsDir, uri) {
+    const prefix = 'feathers-doc://docs/';
+    if (!uri.startsWith(prefix)) {
+        throw new Error(`Invalid URI: ${uri}`);
+    }
+    const relativePath = decodeURIComponent(uri.slice(prefix.length));
+    const resolved = path.resolve(docsDir, relativePath);
+    const root = path.resolve(docsDir);
+    if (!resolved.startsWith(root)) {
+        throw new Error('Path traversal detected');
+    }
+    return resolved;
+}

package/dist/search/embed.js

@@ -0,0 +1,19 @@
+import { pipeline } from '@xenova/transformers';
+class TransformersEmbedder {
+    extractorPromise;
+    constructor(model) {
+        this.extractorPromise = pipeline('feature-extraction', model);
+    }
+    async embed(texts) {
+        const extractor = await this.extractorPromise;
+        const vectors = [];
+        for (const text of texts) {
+            const output = await extractor(text, { pooling: 'mean', normalize: true });
+            vectors.push(Array.from(output.data));
+        }
+        return vectors;
+    }
+}
+export function createEmbedder(model) {
+    return new TransformersEmbedder(model);
+}

package/dist/search/vector-store.js

@@ -0,0 +1,67 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { cosineSimilarity, snippet } from '../utils.js';
+export class VectorStore {
+    pages = [];
+    chunks = [];
+    manifest = null;
+    setData(data) {
+        this.pages = data.pages;
+        this.chunks = data.chunks;
+        this.manifest = data.manifest;
+    }
+    getData() {
+        if (!this.manifest) {
+            throw new Error('Index is not initialized');
+        }
+        return {
+            pages: this.pages,
+            chunks: this.chunks,
+            manifest: this.manifest
+        };
+    }
+    getPages() {
+        return this.pages;
+    }
+    getPageByUri(uri) {
+        return this.pages.find((p) => p.uri === uri);
+    }
+    search(query, queryVector, limit, sectionFilter) {
+        const filter = sectionFilter?.toLowerCase().trim();
+        const hits = this.chunks
+            .filter((c) => !filter || c.sectionPath.toLowerCase().includes(filter) || c.title.toLowerCase().includes(filter))
+            .map((chunk) => {
+            const score = cosineSimilarity(queryVector, chunk.embedding);
+            return {
+                title: chunk.title,
+                uri: chunk.uri,
+                sectionPath: chunk.sectionPath,
+                score,
+                snippet: snippet(chunk.content, query)
+            };
+        })
+            .sort((a, b) => b.score - a.score);
+        const dedup = new Map();
+        for (const hit of hits) {
+            const existing = dedup.get(hit.uri);
+            if (!existing || hit.score > existing.score) {
+                dedup.set(hit.uri, hit);
+            }
+            if (dedup.size >= limit)
+                break;
+        }
+        return Array.from(dedup.values()).slice(0, limit);
+    }
+}
+export function loadIndexedData(indexDir) {
+    const filePath = path.join(indexDir, 'index.json');
+    if (!fs.existsSync(filePath))
+        return null;
+    const raw = fs.readFileSync(filePath, 'utf8');
+    return JSON.parse(raw);
+}
+export function saveIndexedData(indexDir, data) {
+    fs.mkdirSync(indexDir, { recursive: true });
+    const filePath = path.join(indexDir, 'index.json');
+    fs.writeFileSync(filePath, JSON.stringify(data), 'utf8');
+}

package/dist/transport.js

@@ -0,0 +1,16 @@
+/**
+ * Wrap `app.setup` and run `afterSetup` once setup has completed.
+ */
+export function attachSetupHook(app, afterSetup) {
+    const originalSetup = app.setup.bind(app);
+    app.setup = (...args) => {
+        const setupResult = originalSetup(...args);
+        if (setupResult && typeof setupResult.then === 'function') {
+            return setupResult.then(async (value) => {
+                await afterSetup();
+                return value;
+            });
+        }
+        return Promise.resolve(afterSetup()).then(() => setupResult);
+    };
+}

package/dist/types.js

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

package/dist/utils.js

@@ -0,0 +1,25 @@
+import crypto from 'node:crypto';
+/**
+ * Create a deterministic SHA-256 hash for a string payload.
+ */
+export function sha256(input) {
+    return crypto.createHash('sha256').update(input).digest('hex');
+}
+/**
+ * Convert a docs-relative path to the MCP resource URI format.
+ */
+export function toUri(relativePath) {
+    return `feathers-doc://docs/${relativePath.replaceAll('\\', '/')}`;
+}
+/**
+ * Build a compact excerpt around a query match for display/search previews.
+ */
+export function snippet(text, query, max = 280) {
+    const lower = text.toLowerCase();
+    const q = query.toLowerCase();
+    const idx = lower.indexOf(q);
+    if (idx < 0 || text.length <= max)
+        return text.slice(0, max);
+    const start = Math.max(0, idx - Math.floor(max / 3));
+    return text.slice(start, start + max);
+}

package/package.json

@@ -0,0 +1,64 @@
+{
+  "name": "feathersjs-docs-mcp",
+  "version": "0.1.0",
+  "private": false,
+  "type": "module",
+  "description": "Read-only MCP server for discovering and reading FeathersJS documentation",
+  "keywords": [
+    "mcp",
+    "model-context-protocol",
+    "feathers",
+    "feathersjs",
+    "documentation"
+  ],
+  "license": "MIT",
+  "author": "fedevela",
+  "homepage": "https://github.com/fedevela/feathersjs-docs-mcp#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/fedevela/feathersjs-docs-mcp.git"
+  },
+  "bugs": {
+    "url": "https://github.com/fedevela/feathersjs-docs-mcp/issues"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "main": "dist/index.js",
+  "types": "dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js"
+    }
+  },
+  "bin": {
+    "feathersjs-docs-mcp": "dist/index.js"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json",
+    "start": "node dist/index.js",
+    "dev": "tsx src/index.ts",
+    "test:e2e": "npm run build && vitest run --config vitest.e2e.config.ts",
+    "test:e2e:watch": "vitest --config vitest.e2e.config.ts",
+    "prepublishOnly": "npm run build && npm run test:e2e"
+  },
+  "dependencies": {
+    "fastmcp": "^3.33.0",
+    "gray-matter": "^4.0.3",
+    "isomorphic-git": "^1.37.1",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@playwright/test": "^1.58.2",
+    "@types/node": "^25.3.0",
+    "tsx": "^4.21.0",
+    "typescript": "~5.9.3",
+    "vitest": "^4.0.18"
+  }
+}