functype-mcp-server 0.47.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Jordan
+
+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,123 @@
+# functype-mcp-server
+
+MCP server for [functype](https://github.com/jordanburke/functype) — documentation lookup and compile-time TypeScript code validation for AI editors.
+
+## Features
+
+- **`search_docs`** — Search functype documentation by keyword or type name
+- **`get_type_api`** — Detailed API reference for any type (Option, Either, List, IO, etc.)
+- **`get_interfaces`** — Interface hierarchy (Functor, Monad, Foldable, Extractable, etc.)
+- **`validate_code`** — Type-check functype code snippets using the TypeScript Compiler API
+- **`set_functype_version`** — Switch functype version at runtime (installs + reloads docs and types)
+
+The `validate_code` tool is the killer feature: an LLM writes functype code, calls the tool, gets back type errors, and fixes them before showing the user.
+
+## Installation
+
+### Claude Desktop
+
+Add to your Claude Desktop config (`~/Library/Application Support/Claude/claude_desktop_config.json`):
+
+```json
+{
+  "mcpServers": {
+    "functype": {
+      "command": "npx",
+      "args": ["functype-mcp-server"]
+    }
+  }
+}
+```
+
+### Claude Code
+
+Add to your project's `.mcp.json`:
+
+```json
+{
+  "mcpServers": {
+    "functype": {
+      "command": "npx",
+      "args": ["functype-mcp-server"]
+    }
+  }
+}
+```
+
+### From Source
+
+```bash
+git clone https://github.com/jordanburke/functype-mcp-server.git
+cd functype-mcp-server
+pnpm install
+pnpm build
+```
+
+Then configure your MCP client to use `node dist/bin.js`.
+
+## Tools
+
+### `search_docs`
+
+Search functype documentation. Omit query for a full overview.
+
+```
+query?: string  — Type name or keyword (e.g., "Option", "map", "Foldable")
+```
+
+### `get_type_api`
+
+Get detailed API reference for a specific type.
+
+```
+type_name: string              — e.g., "Option", "Either", "List", "IO"
+include_full_interface?: bool  — Include full TypeScript interface definition
+```
+
+### `get_interfaces`
+
+Get the interface hierarchy — Functor, Monad, Foldable, Extractable, etc.
+
+No parameters.
+
+### `validate_code`
+
+Type-check a functype code snippet using the TypeScript compiler.
+
+```
+code: string          — TypeScript code to validate
+auto_import?: bool    — Auto-import functype types if no import present (default: true)
+```
+
+Returns `Validation PASSED` or a list of errors with line, column, message, and TS error code.
+
+### `set_functype_version`
+
+Switch the functype version at runtime. Installs the specified version and reloads all documentation and type definitions.
+
+```
+version: string  — Version to install (e.g., "0.47.0", "latest", ...)
+```
+
+Requires functype >= 0.47.0 for full documentation support. Older versions will still work for type-checking via `validate_code`.
+
+## Environment Variables
+
+| Variable         | Default   | Description                             |
+| ---------------- | --------- | --------------------------------------- |
+| `TRANSPORT_TYPE` | `stdio`   | Transport mode: `stdio` or `httpStream` |
+| `PORT`           | `3000`    | HTTP port (when using httpStream)       |
+| `HOST`           | `0.0.0.0` | HTTP host (when using httpStream)       |
+
+## Development
+
+```bash
+pnpm validate          # format + lint + typecheck + test + build
+pnpm test              # Run tests
+pnpm inspect           # Build + launch MCP Inspector
+pnpm serve:dev         # Dev server with tsx watch
+```
+
+## License
+
+MIT

package/dist/bin.d.ts

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

package/dist/bin.js

@@ -0,0 +1,43 @@
+#!/usr/bin/env node
+//#region src/bin.ts
+if (!process.env.TRANSPORT_TYPE) process.env.TRANSPORT_TYPE = "stdio";
+const args = process.argv.slice(2);
+if (args.includes("--version") || args.includes("-v")) {
+	console.log("0.47.0");
+	process.exit(0);
+}
+if (args.includes("--help") || args.includes("-h")) {
+	console.log(`
+functype-mcp-server v0.47.0
+
+MCP server for functype documentation lookup and TypeScript code validation.
+
+Usage: functype-mcp-server [options]
+
+Options:
+  -v, --version        Show version number
+  -h, --help           Show help
+
+Environment Variables:
+  TRANSPORT_TYPE        Transport mode: "stdio" (default) or "httpStream"
+  PORT                  HTTP port (default: 3000)
+  HOST                  HTTP host (default: 0.0.0.0)
+
+Tools:
+  search_docs           Search functype documentation
+  get_type_api          Get detailed type API reference
+  get_interfaces        Get interface hierarchy
+  validate_code         Type-check functype code snippets
+
+For more information: https://github.com/jordanburke/functype-mcp-server
+`);
+	process.exit(0);
+}
+async function main() {
+	await import("./index.js");
+}
+main().then();
+
+//#endregion
+export {  };
+//# sourceMappingURL=bin.js.map

package/dist/bin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"bin.js","names":[],"sources":["../src/bin.ts"],"sourcesContent":["#!/usr/bin/env node\n\ndeclare const __VERSION__: string\n\nif (!process.env.TRANSPORT_TYPE) {\n  process.env.TRANSPORT_TYPE = \"stdio\"\n}\n\nconst args = process.argv.slice(2)\n\nif (args.includes(\"--version\") || args.includes(\"-v\")) {\n  console.log(__VERSION__)\n  process.exit(0)\n}\n\nif (args.includes(\"--help\") || args.includes(\"-h\")) {\n  console.log(`\nfunctype-mcp-server v${__VERSION__}\n\nMCP server for functype documentation lookup and TypeScript code validation.\n\nUsage: functype-mcp-server [options]\n\nOptions:\n  -v, --version        Show version number\n  -h, --help           Show help\n\nEnvironment Variables:\n  TRANSPORT_TYPE        Transport mode: \"stdio\" (default) or \"httpStream\"\n  PORT                  HTTP port (default: 3000)\n  HOST                  HTTP host (default: 0.0.0.0)\n\nTools:\n  search_docs           Search functype documentation\n  get_type_api          Get detailed type API reference\n  get_interfaces        Get interface hierarchy\n  validate_code         Type-check functype code snippets\n\nFor more information: https://github.com/jordanburke/functype-mcp-server\n`)\n  process.exit(0)\n}\n\nasync function main() {\n  await import(\"./index.js\")\n}\n\nmain().then()\n"],"mappings":";;AAIA,IAAI,CAAC,QAAQ,IAAI,eACf,SAAQ,IAAI,iBAAiB;AAG/B,MAAM,OAAO,QAAQ,KAAK,MAAM,EAAE;AAElC,IAAI,KAAK,SAAS,YAAY,IAAI,KAAK,SAAS,KAAK,EAAE;AACrD,SAAQ,aAAgB;AACxB,SAAQ,KAAK,EAAE;;AAGjB,IAAI,KAAK,SAAS,SAAS,IAAI,KAAK,SAAS,KAAK,EAAE;AAClD,SAAQ,IAAI;;;;;;;;;;;;;;;;;;;;;;;EAuBZ;AACA,SAAQ,KAAK,EAAE;;AAGjB,eAAe,OAAO;AACpB,OAAM,OAAO;;AAGf,MAAM,CAAC,MAAM"}

package/dist/index.d.ts

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

package/dist/index.js

@@ -0,0 +1,379 @@
+import { createRequire } from "node:module";
+import { execFileSync } from "node:child_process";
+import { dirname, join, resolve } from "node:path";
+import { fileURLToPath, pathToFileURL } from "node:url";
+import { FastMCP } from "fastmcp";
+import { z } from "zod";
+import { readFileSync } from "node:fs";
+import ts from "typescript";
+
+//#region src/lib/docs/data.ts
+/**
+* Runtime loader for functype CLI data.
+* Uses dynamic import so the data reflects whichever functype version
+* is installed in node_modules at runtime (not baked in at build time).
+*/
+const require$1 = createRequire(import.meta.url);
+let TYPES = {};
+let INTERFACES = {};
+let CATEGORIES = {};
+let FULL_INTERFACES = {};
+let VERSION = "unknown";
+let initialized = false;
+async function initDocsData(force) {
+	if (initialized && !force) return;
+	try {
+		let cli;
+		if (force) cli = await import(`${pathToFileURL(require$1.resolve("functype/cli")).href}?t=${Date.now()}`);
+		else cli = await import("functype/cli");
+		TYPES = cli.TYPES;
+		INTERFACES = cli.INTERFACES;
+		CATEGORIES = cli.CATEGORIES;
+		FULL_INTERFACES = cli.FULL_INTERFACES;
+		VERSION = cli.VERSION;
+		initialized = true;
+	} catch (err) {
+		if (force) throw err;
+		console.error("[functype-mcp] Failed to load functype/cli data — doc tools will return empty results:", err);
+	}
+}
+
+//#endregion
+//#region src/lib/docs/formatters.ts
+const METHOD_CATEGORIES = [
+	"create",
+	"transform",
+	"extract",
+	"check",
+	"other"
+];
+const formatOverview = () => {
+	const lines = [`# functype ${VERSION} — Scala-inspired FP for TypeScript`, ""];
+	for (const [category, typeNames] of Object.entries(CATEGORIES)) {
+		lines.push(`## ${category}`, "");
+		for (const name of typeNames) {
+			const type = TYPES[name];
+			if (type) {
+				const ifaces = type.interfaces.length > 0 ? ` [${type.interfaces.join(", ")}]` : "";
+				lines.push(`**${name}**${ifaces}`);
+				lines.push(`  ${type.description}`, "");
+			}
+		}
+	}
+	lines.push("---", "Use `get_type_api` for detailed type reference.", "Use `get_interfaces` for interface hierarchy.");
+	return lines.join("\n");
+};
+const formatType = (name, data, includeFullInterface) => {
+	const lines = [
+		`# ${name}<T>${data.interfaces.length > 0 ? ` [${data.interfaces.join(", ")}]` : ""}`,
+		"",
+		data.description,
+		""
+	];
+	for (const cat of METHOD_CATEGORIES) {
+		const methods = data.methods[cat];
+		if (methods && methods.length > 0) {
+			lines.push(`## ${cat.charAt(0).toUpperCase() + cat.slice(1)}`, "");
+			for (const method of methods) lines.push(`- \`${method}\``);
+			lines.push("");
+		}
+	}
+	if (includeFullInterface) {
+		const fullInterface = FULL_INTERFACES[name];
+		if (fullInterface) lines.push("## Full Interface", "", "```typescript", fullInterface, "```");
+	}
+	return lines.join("\n").trimEnd();
+};
+const formatInterfaces = () => {
+	const lines = ["# Interfaces", ""];
+	for (const [name, data] of Object.entries(INTERFACES)) {
+		const ext = data.extends ? ` extends ${data.extends}` : "";
+		lines.push(`## ${name}<A>${ext}`, "", data.description, "");
+		for (const method of data.methods) lines.push(`- \`${method}\``);
+		lines.push("");
+	}
+	return lines.join("\n").trimEnd();
+};
+const searchTypes = (query) => {
+	const q = query.toLowerCase();
+	const matches = [];
+	for (const [name, data] of Object.entries(TYPES)) {
+		const nameMatch = name.toLowerCase().includes(q);
+		const descMatch = data.description.toLowerCase().includes(q);
+		const ifaceMatch = data.interfaces.some((i) => i.toLowerCase().includes(q));
+		const methodMatch = Object.values(data.methods).flat().some((m) => m.toLowerCase().includes(q));
+		if (nameMatch || descMatch || ifaceMatch || methodMatch) matches.push({
+			name,
+			data
+		});
+	}
+	if (matches.length === 0) return `No types found matching "${query}". Available types: ${Object.keys(TYPES).join(", ")}`;
+	if (matches.length === 1) {
+		const match = matches[0];
+		return formatType(match.name, match.data);
+	}
+	const lines = [
+		`# Search results for "${query}"`,
+		"",
+		`Found ${matches.length} matching types:`,
+		""
+	];
+	for (const match of matches) {
+		const ifaces = match.data.interfaces.length > 0 ? ` [${match.data.interfaces.join(", ")}]` : "";
+		lines.push(`**${match.name}**${ifaces}`);
+		lines.push(`  ${match.data.description}`, "");
+	}
+	lines.push("---", "Use `get_type_api` with a specific type name for full details.");
+	return lines.join("\n");
+};
+const getTypeByName = (name) => {
+	const direct = TYPES[name];
+	if (direct) return {
+		name,
+		data: direct
+	};
+	const entry = Object.entries(TYPES).find(([typeName]) => typeName.toLowerCase() === name.toLowerCase());
+	if (entry) return {
+		name: entry[0],
+		data: entry[1]
+	};
+};
+
+//#endregion
+//#region src/lib/validator/compiler-host.ts
+/**
+* Custom TypeScript CompilerHost for in-memory type-checking of functype code.
+* Resolves functype .d.ts files from node_modules for accurate type validation.
+*/
+const require = createRequire(import.meta.url);
+const resolveFunctypeDistDir = () => {
+	const functypeMain = require.resolve("functype");
+	let dir = dirname(functypeMain);
+	for (let i = 0; i < 5; i++) try {
+		readFileSync(join(dir, "package.json"), "utf-8");
+		return join(dir, "dist");
+	} catch {
+		dir = dirname(dir);
+	}
+	return dirname(functypeMain);
+};
+const fileCache = /* @__PURE__ */ new Map();
+const clearFileCache = () => {
+	fileCache.clear();
+};
+const readFileCached = (path) => {
+	if (fileCache.has(path)) return fileCache.get(path);
+	try {
+		const content = readFileSync(path, "utf-8");
+		fileCache.set(path, content);
+		return content;
+	} catch {
+		fileCache.set(path, void 0);
+		return;
+	}
+};
+const VIRTUAL_FILENAME = "/__functype_validate__.ts";
+const compilerOptions = {
+	strict: true,
+	target: ts.ScriptTarget.ES2020,
+	module: ts.ModuleKind.ESNext,
+	moduleResolution: ts.ModuleResolutionKind.Bundler,
+	noEmit: true,
+	noUncheckedIndexedAccess: true,
+	skipLibCheck: true,
+	esModuleInterop: true,
+	allowSyntheticDefaultImports: true,
+	declaration: false,
+	sourceMap: false
+};
+const createCompilerHost = (sourceCode) => {
+	const functypeDistDir = resolveFunctypeDistDir();
+	const defaultHost = ts.createCompilerHost(compilerOptions);
+	return {
+		...defaultHost,
+		getSourceFile(fileName, languageVersion) {
+			if (fileName === VIRTUAL_FILENAME) return ts.createSourceFile(fileName, sourceCode, languageVersion, true);
+			return defaultHost.getSourceFile(fileName, languageVersion);
+		},
+		fileExists(fileName) {
+			if (fileName === VIRTUAL_FILENAME) return true;
+			return defaultHost.fileExists(fileName);
+		},
+		readFile(fileName) {
+			if (fileName === VIRTUAL_FILENAME) return sourceCode;
+			return readFileCached(fileName) ?? defaultHost.readFile(fileName);
+		},
+		resolveModuleNames(moduleNames, containingFile) {
+			return moduleNames.map((moduleName) => {
+				if (moduleName === "functype" || moduleName.startsWith("functype/")) {
+					const subpath = moduleName === "functype" ? "index.d.ts" : moduleName.replace("functype/", "") + ".d.ts";
+					const resolvedFileName = resolve(functypeDistDir, subpath);
+					if (readFileCached(resolvedFileName) !== void 0) return {
+						resolvedFileName,
+						isExternalLibraryImport: true
+					};
+					const indexPath = resolve(functypeDistDir, subpath.replace(".d.ts", "/index.d.ts"));
+					if (readFileCached(indexPath) !== void 0) return {
+						resolvedFileName: indexPath,
+						isExternalLibraryImport: true
+					};
+					return;
+				}
+				return ts.resolveModuleName(moduleName, containingFile, compilerOptions, defaultHost).resolvedModule;
+			});
+		}
+	};
+};
+
+//#endregion
+//#region src/lib/validator/validate.ts
+/**
+* Core validation function — type-checks functype code snippets using the TypeScript Compiler API.
+*/
+const DEFAULT_IMPORTS = `import { Option, Some, None, Either, Right, Left, Try, List, Set, Map, Lazy, LazyList, Task, IO, Cond, Match, Brand, ValidatedBrand, Tuple, Stack, Ok, Err } from "functype"\n`;
+const hasFunctypeImport = (code) => /from\s+["']functype(?:\/[^"']*)?["']/.test(code);
+const validateCode = (code, options = {}) => {
+	const shouldPrepend = (options.autoImport ?? true) && !hasFunctypeImport(code);
+	const importLineCount = shouldPrepend ? 1 : 0;
+	const host = createCompilerHost(shouldPrepend ? DEFAULT_IMPORTS + code : code);
+	const program = ts.createProgram([VIRTUAL_FILENAME], compilerOptions, host);
+	const userDiagnostics = ts.getPreEmitDiagnostics(program).filter((d) => d.file?.fileName === VIRTUAL_FILENAME).map((d) => {
+		const { line, character } = d.file.getLineAndCharacterOfPosition(d.start ?? 0);
+		return {
+			originalLine: line,
+			line: line - importLineCount + 1,
+			column: character + 1,
+			message: ts.flattenDiagnosticMessageText(d.messageText, "\n"),
+			code: d.code,
+			severity: d.category === ts.DiagnosticCategory.Error ? "error" : "warning"
+		};
+	}).filter((d) => !shouldPrepend || d.originalLine >= importLineCount).map(({ originalLine: _, ...rest }) => rest);
+	return {
+		success: userDiagnostics.filter((d) => d.severity === "error").length === 0,
+		diagnostics: userDiagnostics,
+		importsPrepended: shouldPrepend
+	};
+};
+
+//#endregion
+//#region src/index.ts
+const PROJECT_ROOT = dirname(dirname(fileURLToPath(import.meta.url)));
+const SERVER_VERSION = "0.47.0";
+function createServer() {
+	const server = new FastMCP({
+		name: "functype-mcp-server",
+		version: SERVER_VERSION,
+		instructions: `Functype MCP Server — documentation lookup and code validation for the functype TypeScript FP library (v${VERSION}).
+
+Available tools:
+- search_docs: Search functype documentation by keyword or type name
+- get_type_api: Get detailed API reference for a specific type
+- get_interfaces: Get the interface hierarchy (Functor, Monad, Foldable, etc.)
+- validate_code: Type-check functype code snippets at compile time
+- set_functype_version: Switch the functype version at runtime (installs + reloads)
+
+Use validate_code to verify your functype code is type-correct before presenting it to the user.`
+	});
+	server.addTool({
+		name: "search_docs",
+		description: "Search functype documentation by keyword or type name. Omit query for a full overview of all types and categories.",
+		parameters: z.object({ query: z.string().optional().describe("Type name or keyword to search for. Omit for full overview.") }),
+		execute: async (args) => {
+			if (!args.query || args.query.trim() === "") return formatOverview();
+			return searchTypes(args.query);
+		}
+	});
+	server.addTool({
+		name: "get_type_api",
+		description: "Get detailed API reference for a specific functype type including methods by category and optionally the full TypeScript interface definition.",
+		parameters: z.object({
+			type_name: z.string().describe("The type name (e.g., Option, Either, List, IO)"),
+			include_full_interface: z.boolean().optional().default(false).describe("Include full TypeScript interface definition")
+		}),
+		execute: async (args) => {
+			const found = getTypeByName(args.type_name);
+			if (!found) {
+				const available = Object.keys(FULL_INTERFACES).join(", ");
+				return `Type "${args.type_name}" not found. Available types: ${available}`;
+			}
+			return formatType(found.name, found.data, args.include_full_interface);
+		}
+	});
+	server.addTool({
+		name: "get_interfaces",
+		description: "Get the functype interface hierarchy — Functor, Monad, Foldable, Extractable, Matchable, etc. — with their methods and inheritance.",
+		parameters: z.object({}),
+		execute: async () => {
+			return formatInterfaces();
+		}
+	});
+	server.addTool({
+		name: "validate_code",
+		description: "Type-check a functype code snippet using the TypeScript compiler. Returns PASSED or a list of type errors with line/column/message. Use this to verify functype code is type-correct before presenting to users.",
+		parameters: z.object({
+			code: z.string().describe("TypeScript code snippet using functype to type-check"),
+			auto_import: z.boolean().optional().default(true).describe("Automatically import all functype types if no import statement is present. Default: true")
+		}),
+		execute: async (args) => {
+			const result = validateCode(args.code, { autoImport: args.auto_import });
+			if (result.success) return `Validation PASSED${result.importsPrepended ? " (functype imports auto-added)" : ""}\n\nThe code is type-correct.`;
+			const errorLines = result.diagnostics.map((d) => `- Line ${d.line}, Col ${d.column}: ${d.message} (TS${d.code})`);
+			const importNote = result.importsPrepended ? "\n\nNote: functype imports were auto-added." : "";
+			return `Validation FAILED — ${result.diagnostics.length} error(s):\n\n${errorLines.join("\n")}${importNote}`;
+		}
+	});
+	server.addTool({
+		name: "set_functype_version",
+		description: "Switch the functype version at runtime. Installs the specified version and reloads all documentation and type definitions.",
+		parameters: z.object({ version: z.string().describe("The functype version to install (e.g., \"0.46.0\", \"latest\", \"^0.45.0\")") }),
+		execute: async (args) => {
+			const spec = `functype@${args.version}`;
+			try {
+				execFileSync("pnpm", ["add", spec], {
+					cwd: PROJECT_ROOT,
+					stdio: "pipe",
+					timeout: 6e4
+				});
+			} catch (err) {
+				return `Failed to install ${spec}: ${err instanceof Error ? err.message : String(err)}`;
+			}
+			clearFileCache();
+			try {
+				await initDocsData(true);
+			} catch {
+				return `Installed ${spec}, but this version does not export functype/cli. Documentation and type definitions are unavailable. The validator will still use the installed version's .d.ts files. Consider using functype >= 0.47.0 for full MCP support.`;
+			}
+			return `Switched to functype v${VERSION}. Documentation and type definitions have been reloaded.`;
+		}
+	});
+	return server;
+}
+async function main() {
+	await initDocsData();
+	const server = createServer();
+	const useHttp = process.env.TRANSPORT_TYPE === "httpStream" || process.env.TRANSPORT_TYPE === "http";
+	const port = parseInt(process.env.PORT || "3000");
+	const host = process.env.HOST || "0.0.0.0";
+	if (useHttp) {
+		console.error(`[functype-mcp] Starting HTTP server on ${host}:${port}`);
+		await server.start({
+			transportType: "httpStream",
+			httpStream: {
+				port,
+				host,
+				endpoint: "/mcp"
+			}
+		});
+		console.error(`[functype-mcp] HTTP server ready at http://${host}:${port}/mcp`);
+	} else {
+		console.error("[functype-mcp] Starting in stdio mode");
+		await server.start({ transportType: "stdio" });
+	}
+}
+process.on("SIGINT", () => process.exit(0));
+process.on("SIGTERM", () => process.exit(0));
+main().catch(console.error);
+
+//#endregion
+export {  };
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":["require"],"sources":["../src/lib/docs/data.ts","../src/lib/docs/formatters.ts","../src/lib/validator/compiler-host.ts","../src/lib/validator/validate.ts","../src/index.ts"],"sourcesContent":["/**\n * Runtime loader for functype CLI data.\n * Uses dynamic import so the data reflects whichever functype version\n * is installed in node_modules at runtime (not baked in at build time).\n */\n\nimport { createRequire } from \"node:module\"\nimport { pathToFileURL } from \"node:url\"\n\nexport type { InterfaceData, TypeData } from \"functype/cli\"\nimport type { InterfaceData, TypeData } from \"functype/cli\"\n\nconst require = createRequire(import.meta.url)\n\nexport let TYPES: Record<string, TypeData> = {}\nexport let INTERFACES: Record<string, InterfaceData> = {}\nexport let CATEGORIES: Record<string, string[]> = {}\nexport let FULL_INTERFACES: Record<string, string> = {}\nexport let VERSION = \"unknown\"\n\nlet initialized = false\n\nexport async function initDocsData(force?: boolean): Promise<void> {\n  if (initialized && !force) return\n\n  try {\n    let cli: typeof import(\"functype/cli\")\n    if (force) {\n      const resolvedPath = require.resolve(\"functype/cli\")\n      cli = await import(`${pathToFileURL(resolvedPath).href}?t=${Date.now()}`)\n    } else {\n      cli = await import(\"functype/cli\")\n    }\n    TYPES = cli.TYPES\n    INTERFACES = cli.INTERFACES\n    CATEGORIES = cli.CATEGORIES\n    FULL_INTERFACES = cli.FULL_INTERFACES\n    VERSION = cli.VERSION\n    initialized = true\n  } catch (err) {\n    if (force) throw err\n    console.error(\"[functype-mcp] Failed to load functype/cli data — doc tools will return empty results:\", err)\n  }\n}\n","/**\n * Markdown formatters for MCP tool output.\n * Plain TypeScript — no functype dependency in formatters.\n */\n\nimport type { InterfaceData, TypeData } from \"./data\"\nimport { CATEGORIES, FULL_INTERFACES, INTERFACES, TYPES, VERSION } from \"./data\"\n\nconst METHOD_CATEGORIES = [\"create\", \"transform\", \"extract\", \"check\", \"other\"] as const\n\nexport const formatOverview = (): string => {\n  const lines: string[] = [`# functype ${VERSION} — Scala-inspired FP for TypeScript`, \"\"]\n\n  for (const [category, typeNames] of Object.entries(CATEGORIES)) {\n    lines.push(`## ${category}`, \"\")\n    for (const name of typeNames) {\n      const type = TYPES[name]\n      if (type) {\n        const ifaces = type.interfaces.length > 0 ? ` [${type.interfaces.join(\", \")}]` : \"\"\n        lines.push(`**${name}**${ifaces}`)\n        lines.push(`  ${type.description}`, \"\")\n      }\n    }\n  }\n\n  lines.push(\"---\", \"Use `get_type_api` for detailed type reference.\", \"Use `get_interfaces` for interface hierarchy.\")\n  return lines.join(\"\\n\")\n}\n\nexport const formatType = (name: string, data: TypeData, includeFullInterface?: boolean): string => {\n  const ifaceList = data.interfaces.length > 0 ? ` [${data.interfaces.join(\", \")}]` : \"\"\n  const lines: string[] = [`# ${name}<T>${ifaceList}`, \"\", data.description, \"\"]\n\n  for (const cat of METHOD_CATEGORIES) {\n    const methods = data.methods[cat]\n    if (methods && methods.length > 0) {\n      lines.push(`## ${cat.charAt(0).toUpperCase() + cat.slice(1)}`, \"\")\n      for (const method of methods) {\n        lines.push(`- \\`${method}\\``)\n      }\n      lines.push(\"\")\n    }\n  }\n\n  if (includeFullInterface) {\n    const fullInterface = FULL_INTERFACES[name]\n    if (fullInterface) {\n      lines.push(\"## Full Interface\", \"\", \"```typescript\", fullInterface, \"```\")\n    }\n  }\n\n  return lines.join(\"\\n\").trimEnd()\n}\n\nexport const formatInterfaces = (): string => {\n  const lines: string[] = [\"# Interfaces\", \"\"]\n\n  for (const [name, data] of Object.entries(INTERFACES)) {\n    const ext = data.extends ? ` extends ${data.extends}` : \"\"\n    lines.push(`## ${name}<A>${ext}`, \"\", data.description, \"\")\n    for (const method of data.methods) {\n      lines.push(`- \\`${method}\\``)\n    }\n    lines.push(\"\")\n  }\n\n  return lines.join(\"\\n\").trimEnd()\n}\n\nexport const searchTypes = (query: string): string => {\n  const q = query.toLowerCase()\n  const matches: Array<{ name: string; data: TypeData }> = []\n\n  for (const [name, data] of Object.entries(TYPES)) {\n    const nameMatch = name.toLowerCase().includes(q)\n    const descMatch = data.description.toLowerCase().includes(q)\n    const ifaceMatch = data.interfaces.some((i) => i.toLowerCase().includes(q))\n    const methodMatch = Object.values(data.methods)\n      .flat()\n      .some((m) => m.toLowerCase().includes(q))\n\n    if (nameMatch || descMatch || ifaceMatch || methodMatch) {\n      matches.push({ name, data })\n    }\n  }\n\n  if (matches.length === 0) {\n    return `No types found matching \"${query}\". Available types: ${Object.keys(TYPES).join(\", \")}`\n  }\n\n  if (matches.length === 1) {\n    const match = matches[0]!\n    return formatType(match.name, match.data)\n  }\n\n  const lines: string[] = [`# Search results for \"${query}\"`, \"\", `Found ${matches.length} matching types:`, \"\"]\n  for (const match of matches) {\n    const ifaces = match.data.interfaces.length > 0 ? ` [${match.data.interfaces.join(\", \")}]` : \"\"\n    lines.push(`**${match.name}**${ifaces}`)\n    lines.push(`  ${match.data.description}`, \"\")\n  }\n\n  lines.push(\"---\", \"Use `get_type_api` with a specific type name for full details.\")\n  return lines.join(\"\\n\")\n}\n\nexport const getTypeByName = (name: string): { name: string; data: TypeData } | undefined => {\n  const direct = TYPES[name]\n  if (direct) return { name, data: direct }\n\n  const entry = Object.entries(TYPES).find(([typeName]) => typeName.toLowerCase() === name.toLowerCase())\n  if (entry) return { name: entry[0], data: entry[1] }\n\n  return undefined\n}\n\nexport const getInterfaceByName = (name: string): { name: string; data: InterfaceData } | undefined => {\n  const direct = INTERFACES[name]\n  if (direct) return { name, data: direct }\n\n  const entry = Object.entries(INTERFACES).find(([ifaceName]) => ifaceName.toLowerCase() === name.toLowerCase())\n  if (entry) return { name: entry[0], data: entry[1] }\n\n  return undefined\n}\n","/**\n * Custom TypeScript CompilerHost for in-memory type-checking of functype code.\n * Resolves functype .d.ts files from node_modules for accurate type validation.\n */\n\nimport { readFileSync } from \"node:fs\"\nimport { createRequire } from \"node:module\"\nimport { dirname, join, resolve } from \"node:path\"\n\nimport ts from \"typescript\"\n\nconst require = createRequire(import.meta.url)\n\nconst resolveFunctypeDistDir = (): string => {\n  // Resolve the main entry point, then walk up to find the dist dir\n  const functypeMain = require.resolve(\"functype\")\n  // functypeMain is something like .../node_modules/functype/dist/index.js\n  // Walk up until we find a directory containing package.json\n  let dir = dirname(functypeMain)\n  for (let i = 0; i < 5; i++) {\n    try {\n      readFileSync(join(dir, \"package.json\"), \"utf-8\")\n      return join(dir, \"dist\")\n    } catch {\n      dir = dirname(dir)\n    }\n  }\n  // Fallback: assume dist is sibling to main\n  return dirname(functypeMain)\n}\n\nconst fileCache = new Map<string, string | undefined>()\n\nexport const clearFileCache = (): void => {\n  fileCache.clear()\n}\n\nconst readFileCached = (path: string): string | undefined => {\n  if (fileCache.has(path)) return fileCache.get(path)\n  try {\n    const content = readFileSync(path, \"utf-8\")\n    fileCache.set(path, content)\n    return content\n  } catch {\n    fileCache.set(path, undefined)\n    return undefined\n  }\n}\n\nexport const VIRTUAL_FILENAME = \"/__functype_validate__.ts\"\n\nexport const compilerOptions: ts.CompilerOptions = {\n  strict: true,\n  target: ts.ScriptTarget.ES2020,\n  module: ts.ModuleKind.ESNext,\n  moduleResolution: ts.ModuleResolutionKind.Bundler,\n  noEmit: true,\n  noUncheckedIndexedAccess: true,\n  skipLibCheck: true,\n  esModuleInterop: true,\n  allowSyntheticDefaultImports: true,\n  declaration: false,\n  sourceMap: false,\n}\n\nexport const createCompilerHost = (sourceCode: string): ts.CompilerHost => {\n  const functypeDistDir = resolveFunctypeDistDir()\n  const defaultHost = ts.createCompilerHost(compilerOptions)\n\n  const host: ts.CompilerHost = {\n    ...defaultHost,\n\n    getSourceFile(fileName, languageVersion) {\n      if (fileName === VIRTUAL_FILENAME) {\n        return ts.createSourceFile(fileName, sourceCode, languageVersion, true)\n      }\n      return defaultHost.getSourceFile(fileName, languageVersion)\n    },\n\n    fileExists(fileName) {\n      if (fileName === VIRTUAL_FILENAME) return true\n      return defaultHost.fileExists(fileName)\n    },\n\n    readFile(fileName) {\n      if (fileName === VIRTUAL_FILENAME) return sourceCode\n      return readFileCached(fileName) ?? defaultHost.readFile(fileName)\n    },\n\n    resolveModuleNames(moduleNames, containingFile) {\n      return moduleNames.map((moduleName): ts.ResolvedModule | undefined => {\n        if (moduleName === \"functype\" || moduleName.startsWith(\"functype/\")) {\n          const subpath = moduleName === \"functype\" ? \"index.d.ts\" : moduleName.replace(\"functype/\", \"\") + \".d.ts\"\n          const resolvedFileName = resolve(functypeDistDir, subpath)\n          if (readFileCached(resolvedFileName) !== undefined) {\n            return { resolvedFileName, isExternalLibraryImport: true }\n          }\n          // Try with /index.d.ts for subpath modules\n          const indexPath = resolve(functypeDistDir, subpath.replace(\".d.ts\", \"/index.d.ts\"))\n          if (readFileCached(indexPath) !== undefined) {\n            return { resolvedFileName: indexPath, isExternalLibraryImport: true }\n          }\n          return undefined\n        }\n\n        const result = ts.resolveModuleName(moduleName, containingFile, compilerOptions, defaultHost)\n        return result.resolvedModule\n      })\n    },\n  }\n\n  return host\n}\n","/**\n * Core validation function — type-checks functype code snippets using the TypeScript Compiler API.\n */\n\nimport ts from \"typescript\"\n\nimport { compilerOptions, createCompilerHost, VIRTUAL_FILENAME } from \"./compiler-host\"\nimport type { ValidateOptions, ValidationDiagnostic, ValidationResult } from \"./types\"\n\nconst DEFAULT_IMPORTS = `import { Option, Some, None, Either, Right, Left, Try, List, Set, Map, Lazy, LazyList, Task, IO, Cond, Match, Brand, ValidatedBrand, Tuple, Stack, Ok, Err } from \"functype\"\\n`\n\nconst hasFunctypeImport = (code: string): boolean => /from\\s+[\"']functype(?:\\/[^\"']*)?[\"']/.test(code)\n\nexport const validateCode = (code: string, options: ValidateOptions = {}): ValidationResult => {\n  const autoImport = options.autoImport ?? true\n  const shouldPrepend = autoImport && !hasFunctypeImport(code)\n  const importLineCount = shouldPrepend ? 1 : 0\n  const fullCode = shouldPrepend ? DEFAULT_IMPORTS + code : code\n\n  const host = createCompilerHost(fullCode)\n  const program = ts.createProgram([VIRTUAL_FILENAME], compilerOptions, host)\n  const allDiagnostics = ts.getPreEmitDiagnostics(program)\n\n  const fileDiagnostics = allDiagnostics.filter((d) => d.file?.fileName === VIRTUAL_FILENAME)\n\n  const rawDiagnostics = fileDiagnostics.map((d) => {\n    const { line, character } = d.file!.getLineAndCharacterOfPosition(d.start ?? 0)\n    return {\n      originalLine: line,\n      line: line - importLineCount + 1,\n      column: character + 1,\n      message: ts.flattenDiagnosticMessageText(d.messageText, \"\\n\"),\n      code: d.code,\n      severity: (d.category === ts.DiagnosticCategory.Error ? \"error\" : \"warning\") as \"error\" | \"warning\",\n    }\n  })\n\n  // Filter out diagnostics from the prepended import line(s) and map to final type\n  const userDiagnostics: ValidationDiagnostic[] = rawDiagnostics\n    .filter((d) => !shouldPrepend || d.originalLine >= importLineCount)\n    .map(({ originalLine: _, ...rest }) => rest)\n\n  return {\n    success: userDiagnostics.filter((d) => d.severity === \"error\").length === 0,\n    diagnostics: userDiagnostics,\n    importsPrepended: shouldPrepend,\n  }\n}\n","import { execFileSync } from \"node:child_process\"\nimport { dirname } from \"node:path\"\nimport { fileURLToPath } from \"node:url\"\n\nimport { FastMCP } from \"fastmcp\"\nimport { z } from \"zod\"\n\nimport { FULL_INTERFACES, initDocsData, VERSION } from \"./lib/docs/data\"\nimport { formatInterfaces, formatOverview, formatType, getTypeByName, searchTypes } from \"./lib/docs/formatters\"\nimport { clearFileCache } from \"./lib/validator/compiler-host\"\nimport { validateCode } from \"./lib/validator/validate\"\n\nconst __dirname = dirname(fileURLToPath(import.meta.url))\nconst PROJECT_ROOT = dirname(__dirname)\n\ndeclare const __VERSION__: string\nconst SERVER_VERSION = (\n  typeof __VERSION__ !== \"undefined\" ? __VERSION__ : \"0.0.0-dev\"\n) as `${number}.${number}.${number}`\n\nfunction createServer() {\n  const server = new FastMCP({\n    name: \"functype-mcp-server\",\n    version: SERVER_VERSION,\n    instructions: `Functype MCP Server — documentation lookup and code validation for the functype TypeScript FP library (v${VERSION}).\n\nAvailable tools:\n- search_docs: Search functype documentation by keyword or type name\n- get_type_api: Get detailed API reference for a specific type\n- get_interfaces: Get the interface hierarchy (Functor, Monad, Foldable, etc.)\n- validate_code: Type-check functype code snippets at compile time\n- set_functype_version: Switch the functype version at runtime (installs + reloads)\n\nUse validate_code to verify your functype code is type-correct before presenting it to the user.`,\n  })\n\n  server.addTool({\n    name: \"search_docs\",\n    description:\n      \"Search functype documentation by keyword or type name. Omit query for a full overview of all types and categories.\",\n    parameters: z.object({\n      query: z.string().optional().describe(\"Type name or keyword to search for. Omit for full overview.\"),\n    }),\n    execute: async (args) => {\n      if (!args.query || args.query.trim() === \"\") {\n        return formatOverview()\n      }\n      return searchTypes(args.query)\n    },\n  })\n\n  server.addTool({\n    name: \"get_type_api\",\n    description:\n      \"Get detailed API reference for a specific functype type including methods by category and optionally the full TypeScript interface definition.\",\n    parameters: z.object({\n      type_name: z.string().describe(\"The type name (e.g., Option, Either, List, IO)\"),\n      include_full_interface: z\n        .boolean()\n        .optional()\n        .default(false)\n        .describe(\"Include full TypeScript interface definition\"),\n    }),\n    execute: async (args) => {\n      const found = getTypeByName(args.type_name)\n      if (!found) {\n        const available = Object.keys(FULL_INTERFACES).join(\", \")\n        return `Type \"${args.type_name}\" not found. Available types: ${available}`\n      }\n      return formatType(found.name, found.data, args.include_full_interface)\n    },\n  })\n\n  server.addTool({\n    name: \"get_interfaces\",\n    description:\n      \"Get the functype interface hierarchy — Functor, Monad, Foldable, Extractable, Matchable, etc. — with their methods and inheritance.\",\n    parameters: z.object({}),\n    execute: async () => {\n      return formatInterfaces()\n    },\n  })\n\n  server.addTool({\n    name: \"validate_code\",\n    description:\n      \"Type-check a functype code snippet using the TypeScript compiler. Returns PASSED or a list of type errors with line/column/message. Use this to verify functype code is type-correct before presenting to users.\",\n    parameters: z.object({\n      code: z.string().describe(\"TypeScript code snippet using functype to type-check\"),\n      auto_import: z\n        .boolean()\n        .optional()\n        .default(true)\n        .describe(\"Automatically import all functype types if no import statement is present. Default: true\"),\n    }),\n    execute: async (args) => {\n      const result = validateCode(args.code, { autoImport: args.auto_import })\n\n      if (result.success) {\n        const importNote = result.importsPrepended ? \" (functype imports auto-added)\" : \"\"\n        return `Validation PASSED${importNote}\\n\\nThe code is type-correct.`\n      }\n\n      const errorLines = result.diagnostics.map((d) => `- Line ${d.line}, Col ${d.column}: ${d.message} (TS${d.code})`)\n      const importNote = result.importsPrepended ? \"\\n\\nNote: functype imports were auto-added.\" : \"\"\n\n      return `Validation FAILED — ${result.diagnostics.length} error(s):\\n\\n${errorLines.join(\"\\n\")}${importNote}`\n    },\n  })\n\n  server.addTool({\n    name: \"set_functype_version\",\n    description:\n      \"Switch the functype version at runtime. Installs the specified version and reloads all documentation and type definitions.\",\n    parameters: z.object({\n      version: z.string().describe('The functype version to install (e.g., \"0.46.0\", \"latest\", \"^0.45.0\")'),\n    }),\n    execute: async (args) => {\n      const spec = `functype@${args.version}`\n      try {\n        execFileSync(\"pnpm\", [\"add\", spec], { cwd: PROJECT_ROOT, stdio: \"pipe\", timeout: 60_000 })\n      } catch (err) {\n        const message = err instanceof Error ? err.message : String(err)\n        return `Failed to install ${spec}: ${message}`\n      }\n\n      clearFileCache()\n\n      try {\n        await initDocsData(true)\n      } catch {\n        return `Installed ${spec}, but this version does not export functype/cli. Documentation and type definitions are unavailable. The validator will still use the installed version's .d.ts files. Consider using functype >= 0.47.0 for full MCP support.`\n      }\n\n      return `Switched to functype v${VERSION}. Documentation and type definitions have been reloaded.`\n    },\n  })\n\n  return server\n}\n\nasync function main() {\n  await initDocsData()\n\n  const server = createServer()\n\n  const useHttp = process.env.TRANSPORT_TYPE === \"httpStream\" || process.env.TRANSPORT_TYPE === \"http\"\n  const port = parseInt(process.env.PORT || \"3000\")\n  const host = process.env.HOST || \"0.0.0.0\"\n\n  if (useHttp) {\n    console.error(`[functype-mcp] Starting HTTP server on ${host}:${port}`)\n    await server.start({\n      transportType: \"httpStream\",\n      httpStream: { port, host, endpoint: \"/mcp\" },\n    })\n    console.error(`[functype-mcp] HTTP server ready at http://${host}:${port}/mcp`)\n  } else {\n    console.error(\"[functype-mcp] Starting in stdio mode\")\n    await server.start({ transportType: \"stdio\" })\n  }\n}\n\nprocess.on(\"SIGINT\", () => process.exit(0))\nprocess.on(\"SIGTERM\", () => process.exit(0))\n\nmain().catch(console.error)\n"],"mappings":"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"}

package/package.json

@@ -0,0 +1,74 @@
+{
+  "name": "functype-mcp-server",
+  "version": "0.47.0",
+  "description": "MCP server for functype documentation lookup and TypeScript code validation",
+  "keywords": [
+    "mcp",
+    "functype",
+    "typescript",
+    "functional-programming",
+    "model-context-protocol",
+    "claude",
+    "ai-assistant",
+    "fastmcp",
+    "type-checking"
+  ],
+  "author": "Jordan Burke <jordan.burke@gmail.com>",
+  "license": "MIT",
+  "homepage": "https://github.com/jordanburke/functype-mcp-server#readme",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jordanburke/functype-mcp-server.git"
+  },
+  "bugs": {
+    "url": "https://github.com/jordanburke/functype-mcp-server/issues"
+  },
+  "bin": {
+    "functype-mcp-server": "dist/bin.js"
+  },
+  "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    }
+  },
+  "files": [
+    "dist/",
+    "README.md",
+    "LICENSE"
+  ],
+  "dependencies": {
+    "fastmcp": "^3.33.0",
+    "functype": "^0.47.0",
+    "typescript": "^5.9.3",
+    "zod": "^4.3.6"
+  },
+  "devDependencies": {
+    "@types/node": "^24.10.13",
+    "ts-builds": "^2.4.0",
+    "tsdown": "^0.20.3",
+    "tsx": "^4.21.0"
+  },
+  "prettier": "ts-builds/prettier",
+  "scripts": {
+    "validate": "ts-builds validate",
+    "format": "ts-builds format",
+    "format:check": "ts-builds format:check",
+    "lint": "ts-builds lint",
+    "lint:check": "ts-builds lint:check",
+    "typecheck": "ts-builds typecheck",
+    "test": "ts-builds test",
+    "test:watch": "ts-builds test:watch",
+    "test:coverage": "ts-builds test:coverage",
+    "build": "NODE_ENV=production ts-builds build",
+    "dev": "ts-builds dev",
+    "inspect": "pnpm build && npx @modelcontextprotocol/inspector dist/index.js",
+    "serve": "pnpm build && node dist/index.js",
+    "serve:dev": "tsx watch src/index.ts"
+  }
+}