docsmith-mcp 0.0.1-beta.1

package/dist/index.js

@@ -0,0 +1,679 @@
+#!/usr/bin/env node
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema } from "@modelcontextprotocol/sdk/types.js";
+import { z } from "zod";
+import { runPy } from "@mcpc-tech/code-runner-mcp";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join, resolve } from "path";
+
+//#region src/code-runner.ts
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+/**
+* Convert absolute file path to Pyodide virtual path
+* Determines the mount root and converts the path accordingly
+*
+* @param filePath - Absolute path to the file
+* @returns Object with mountRoot (host path) and virtualPath (Pyodide path)
+*/
+function getFileSystemMapping(filePath) {
+	const absolutePath = resolve(filePath);
+	const mountRoot = dirname(absolutePath);
+	const virtualPath = absolutePath;
+	return {
+		mountRoot,
+		virtualPath
+	};
+}
+/**
+* Run a Python script file using code-runner-mcp
+*
+* @param scriptPath - Path to the Python script (relative to baseDir)
+* @param options - Execution options
+* @returns The execution result
+*/
+async function runPythonFile(scriptPath, options = {}) {
+	const { args = [], packages = {}, baseDir = "python", filePaths = [] } = options;
+	const fullPath = join(__dirname, "..", baseDir, scriptPath);
+	const scriptContent = readFileSync(fullPath, "utf-8");
+	const wrapperCode = `
+import sys
+import json
+
+# Set command line arguments
+sys.argv = ['${scriptPath}'] + ${JSON.stringify(args)}
+
+# Execute the script
+${scriptContent}
+`;
+	let mountRoot = join(__dirname, "..");
+	if (filePaths.length > 0) {
+		const mapping = getFileSystemMapping(filePaths[0]);
+		mountRoot = mapping.mountRoot;
+	}
+	const runPyOptions = {
+		packages,
+		nodeFSMountPoint: mountRoot,
+		nodeFSRoot: mountRoot
+	};
+	const stream = await runPy(wrapperCode, runPyOptions);
+	const reader = stream.getReader();
+	const decoder = new TextDecoder();
+	let stdout = "";
+	let stderr = "";
+	let error = "";
+	try {
+		while (true) {
+			const { done, value } = await reader.read();
+			if (done) break;
+			const chunk = decoder.decode(value, { stream: true });
+			if (chunk.startsWith("[stderr] ")) stderr += chunk.slice(9);
+			else if (chunk.startsWith("[err]")) error += chunk;
+			else stdout += chunk;
+		}
+	} catch (streamError) {
+		return { error: String(streamError) };
+	}
+	if (error) return { error: error.replace(/\[err\]\[py\]\s*/g, "").trim() };
+	const lines = stdout.trim().split("\n");
+	const lastLine = lines[lines.length - 1];
+	try {
+		return JSON.parse(lastLine);
+	} catch {
+		return {
+			stdout,
+			stderr
+		};
+	}
+}
+
+//#endregion
+//#region src/utils.ts
+/**
+* Utility functions for document processing
+*/
+/**
+* Detect file type from file extension
+*/
+function detectFileType(filePath) {
+	const ext = filePath.toLowerCase().split(".").pop();
+	if (ext === "xlsx" || ext === "xls") return "excel";
+	if (ext === "docx") return "word";
+	if (ext === "pdf") return "pdf";
+	if (ext === "txt" || ext === "csv" || ext === "md" || ext === "json" || ext === "yaml" || ext === "yml") return "text";
+	return null;
+}
+/**
+* Get required packages for each file type
+*/
+function getPackages(fileType) {
+	const packages = {
+		excel: { openpyxl: "openpyxl" },
+		word: { docx: "python-docx" },
+		pdf: { PyPDF2: "PyPDF2" },
+		text: {}
+	};
+	return packages[fileType] || {};
+}
+/**
+* Get environment configuration
+*/
+function getConfig() {
+	return {
+		rawFullRead: process.env.DOC_RAW_FULL_READ === "true",
+		pageSize: parseInt(process.env.DOC_PAGE_SIZE || "100", 10),
+		maxFileSize: parseInt(process.env.DOC_MAX_FILE_SIZE || "50", 10) * 1024 * 1024
+	};
+}
+
+//#endregion
+//#region src/index.ts
+const ReadDocumentSchema = z.object({
+	file_path: z.string().describe("Absolute path to the document file"),
+	mode: z.enum(["raw", "paginated"]).optional().describe("Read mode: 'raw' for full content, 'paginated' for chunked reading"),
+	page: z.number().optional().describe("Page number for paginated mode (1-based)"),
+	page_size: z.number().optional().describe("Items per page for paginated mode"),
+	sheet_name: z.string().optional().describe("Sheet name for Excel files")
+});
+const WriteDocumentSchema = z.object({
+	file_path: z.string().describe("Absolute path to save the document"),
+	format: z.enum([
+		"excel",
+		"word",
+		"text"
+	]).describe("Document format"),
+	data: z.any().describe("Document data structure")
+});
+const GetDocumentInfoSchema = z.object({ file_path: z.string().describe("Absolute path to the document file") });
+const server = new Server({
+	name: "docsmith-mcp",
+	version: "0.1.0"
+}, { capabilities: { tools: {} } });
+const BaseOutputSchema = {
+	type: "object",
+	properties: {
+		success: {
+			type: "boolean",
+			description: "Operation success status"
+		},
+		error: {
+			type: "string",
+			description: "Error message if failed"
+		}
+	}
+};
+const PaginationSchema = {
+	current_page: {
+		type: "number",
+		description: "Current page number"
+	},
+	page_size: {
+		type: "number",
+		description: "Items per page"
+	},
+	total_pages: {
+		type: "number",
+		description: "Total number of pages"
+	},
+	page: {
+		type: "number",
+		description: "Current page number (alternative)"
+	},
+	has_more: {
+		type: "boolean",
+		description: "Whether more pages exist"
+	}
+};
+const ExcelReadOutputSchema = {
+	type: "object",
+	properties: {
+		sheet_name: {
+			type: "string",
+			description: "Active sheet name"
+		},
+		sheets: {
+			type: "array",
+			items: { type: "string" },
+			description: "All sheet names"
+		},
+		total_rows: {
+			type: "number",
+			description: "Total rows in sheet"
+		},
+		total_cols: {
+			type: "number",
+			description: "Total columns in sheet"
+		},
+		data: {
+			type: "array",
+			items: {
+				type: "array",
+				items: {}
+			},
+			description: "Sheet data as array of rows"
+		},
+		...PaginationSchema
+	}
+};
+const WordReadOutputSchema = {
+	type: "object",
+	properties: {
+		paragraphs: {
+			type: "array",
+			items: { type: "string" },
+			description: "Document paragraphs"
+		},
+		tables: {
+			type: "array",
+			items: {
+				type: "array",
+				items: {
+					type: "array",
+					items: { type: "string" }
+				}
+			},
+			description: "Tables data"
+		},
+		total_paragraphs: {
+			type: "number",
+			description: "Total paragraph count"
+		},
+		total_tables: {
+			type: "number",
+			description: "Total table count"
+		},
+		...PaginationSchema
+	}
+};
+const PDFReadOutputSchema = {
+	type: "object",
+	properties: {
+		total_pages: {
+			type: "number",
+			description: "Total pages in PDF"
+		},
+		content: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					page_number: { type: "number" },
+					text: { type: "string" }
+				}
+			},
+			description: "Page content array"
+		},
+		current_page_group: { type: "number" },
+		page_size: { type: "number" }
+	}
+};
+const TextReadOutputSchema = {
+	type: "object",
+	properties: {
+		...BaseOutputSchema.properties,
+		content: {
+			type: "string",
+			description: "Text content"
+		},
+		total_lines: {
+			type: "number",
+			description: "Total line count"
+		},
+		encoding: {
+			type: "string",
+			description: "File encoding"
+		},
+		...PaginationSchema
+	}
+};
+const CSVReadOutputSchema = {
+	type: "object",
+	properties: {
+		...BaseOutputSchema.properties,
+		headers: {
+			type: "array",
+			items: { type: "string" },
+			description: "CSV headers"
+		},
+		data: {
+			type: "array",
+			items: { type: "object" },
+			description: "Structured data as array of objects"
+		},
+		total_rows: {
+			type: "number",
+			description: "Total data rows"
+		},
+		encoding: {
+			type: "string",
+			description: "File encoding"
+		},
+		...PaginationSchema
+	}
+};
+const JSONReadOutputSchema = {
+	type: "object",
+	properties: {
+		...BaseOutputSchema.properties,
+		data: {
+			type: "object",
+			description: "Parsed JSON data"
+		},
+		encoding: {
+			type: "string",
+			description: "File encoding"
+		}
+	}
+};
+const WriteOutputSchema = {
+	type: "object",
+	properties: {
+		success: {
+			type: "boolean",
+			description: "Write operation success"
+		},
+		file_path: {
+			type: "string",
+			description: "Written file path"
+		},
+		message: {
+			type: "string",
+			description: "Success message"
+		},
+		error: {
+			type: "string",
+			description: "Error message if failed"
+		}
+	}
+};
+const ExcelInfoOutputSchema = {
+	type: "object",
+	properties: {
+		sheets: {
+			type: "array",
+			items: {
+				type: "object",
+				properties: {
+					name: { type: "string" },
+					rows: { type: "number" },
+					cols: { type: "number" }
+				}
+			},
+			description: "Sheet information"
+		},
+		file_size: {
+			type: "number",
+			description: "File size in bytes"
+		}
+	}
+};
+const WordInfoOutputSchema = {
+	type: "object",
+	properties: {
+		paragraphs: {
+			type: "number",
+			description: "Paragraph count"
+		},
+		tables: {
+			type: "number",
+			description: "Table count"
+		},
+		file_size: {
+			type: "number",
+			description: "File size in bytes"
+		}
+	}
+};
+const PDFInfoOutputSchema = {
+	type: "object",
+	properties: {
+		pages: {
+			type: "number",
+			description: "Page count"
+		},
+		file_size: {
+			type: "number",
+			description: "File size in bytes"
+		},
+		total_words: {
+			type: "number",
+			description: "Total word count"
+		}
+	}
+};
+const TextInfoOutputSchema = {
+	type: "object",
+	properties: {
+		...BaseOutputSchema.properties,
+		file_size: {
+			type: "number",
+			description: "File size in bytes"
+		},
+		line_count: {
+			type: "number",
+			description: "Line count"
+		},
+		encoding: {
+			type: "string",
+			description: "File encoding"
+		},
+		file_type: {
+			type: "string",
+			description: "File extension"
+		},
+		headers: {
+			type: "array",
+			items: { type: "string" }
+		},
+		total_rows: { type: "number" },
+		total_cols: { type: "number" },
+		item_count: { type: "number" },
+		key_count: { type: "number" }
+	}
+};
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+	return { tools: [
+		{
+			name: "read_document",
+			description: "Read document content (Excel, Word, PDF, TXT, CSV, Markdown, JSON, YAML). Supports raw full read or paginated mode.",
+			inputSchema: {
+				type: "object",
+				properties: {
+					file_path: {
+						type: "string",
+						description: "Absolute path to the document file"
+					},
+					mode: {
+						type: "string",
+						enum: ["raw", "paginated"],
+						description: "Read mode"
+					},
+					page: {
+						type: "number",
+						description: "Page number for paginated mode"
+					},
+					page_size: {
+						type: "number",
+						description: "Items per page"
+					},
+					sheet_name: {
+						type: "string",
+						description: "Sheet name for Excel files"
+					}
+				},
+				required: ["file_path"]
+			},
+			outputSchema: {
+				type: "object",
+				description: "Returns different structures based on file type: Excel (sheet data), Word (paragraphs/tables), PDF (page content), Text (plain text), CSV (structured rows), JSON (parsed object)",
+				oneOf: [
+					ExcelReadOutputSchema,
+					WordReadOutputSchema,
+					PDFReadOutputSchema,
+					TextReadOutputSchema,
+					CSVReadOutputSchema,
+					JSONReadOutputSchema
+				]
+			}
+		},
+		{
+			name: "write_document",
+			description: "Write document content (Excel, Word, Text)",
+			inputSchema: {
+				type: "object",
+				properties: {
+					file_path: {
+						type: "string",
+						description: "Absolute path to save the document"
+					},
+					format: {
+						type: "string",
+						enum: [
+							"excel",
+							"word",
+							"text"
+						],
+						description: "Document format"
+					},
+					data: { description: "Document data structure. Excel: array of rows [[cell1, cell2], ...]. Word: {paragraphs: string[], tables?: [[[cell]]]}. Text/CSV/JSON: string or object" }
+				},
+				required: [
+					"file_path",
+					"format",
+					"data"
+				]
+			},
+			outputSchema: WriteOutputSchema
+		},
+		{
+			name: "get_document_info",
+			description: "Get document metadata (page count, sheet count, file size, etc.)",
+			inputSchema: {
+				type: "object",
+				properties: { file_path: {
+					type: "string",
+					description: "Absolute path to the document file"
+				} },
+				required: ["file_path"]
+			},
+			outputSchema: {
+				type: "object",
+				description: "Returns metadata based on file type",
+				oneOf: [
+					ExcelInfoOutputSchema,
+					WordInfoOutputSchema,
+					PDFInfoOutputSchema,
+					TextInfoOutputSchema
+				]
+			}
+		}
+	] };
+});
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+	const { name, arguments: args } = request.params;
+	try {
+		if (name === "read_document") {
+			const params = ReadDocumentSchema.parse(args);
+			const fileType = detectFileType(params.file_path);
+			if (!fileType) throw new Error(`Unsupported file type: ${params.file_path}`);
+			const config = getConfig();
+			const mode = params.mode || (config.rawFullRead ? "raw" : "paginated");
+			const page = mode === "paginated" ? params.page || 1 : void 0;
+			const pageSize = params.page_size || config.pageSize;
+			let scriptName;
+			let scriptArgs;
+			if (fileType === "excel") {
+				scriptName = "excel_handler.py";
+				scriptArgs = ["read", params.file_path];
+				if (params.sheet_name) scriptArgs.push(params.sheet_name);
+				if (page) {
+					scriptArgs.push(String(page));
+					scriptArgs.push(String(pageSize));
+				}
+			} else if (fileType === "word") {
+				scriptName = "word_handler.py";
+				scriptArgs = ["read", params.file_path];
+				if (page) {
+					scriptArgs.push(String(page));
+					scriptArgs.push(String(pageSize));
+				}
+			} else if (fileType === "pdf") {
+				scriptName = "pdf_handler.py";
+				scriptArgs = ["read", params.file_path];
+				if (page) {
+					scriptArgs.push(String(page));
+					scriptArgs.push(String(Math.min(pageSize, 10)));
+				}
+			} else {
+				scriptName = "text_handler.py";
+				scriptArgs = ["read", params.file_path];
+				if (page) {
+					scriptArgs.push(String(page));
+					scriptArgs.push(String(pageSize));
+				}
+			}
+			const result = await runPythonFile(scriptName, {
+				args: scriptArgs,
+				packages: getPackages(fileType),
+				filePaths: [params.file_path]
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				structuredContent: result
+			};
+		}
+		if (name === "write_document") {
+			const params = WriteDocumentSchema.parse(args);
+			let scriptName;
+			let scriptArgs;
+			if (params.format === "excel") {
+				scriptName = "excel_handler.py";
+				scriptArgs = [
+					"write",
+					params.file_path,
+					JSON.stringify(params.data)
+				];
+			} else if (params.format === "word") {
+				scriptName = "word_handler.py";
+				const paragraphs = params.data.paragraphs || [];
+				const tables = params.data.tables || null;
+				scriptArgs = [
+					"write",
+					params.file_path,
+					JSON.stringify(paragraphs)
+				];
+				if (tables) scriptArgs.push(JSON.stringify(tables));
+			} else if (params.format === "text") {
+				scriptName = "text_handler.py";
+				const content = typeof params.data === "string" ? params.data : JSON.stringify(params.data);
+				scriptArgs = [
+					"write",
+					params.file_path,
+					content
+				];
+			} else throw new Error(`Unsupported write format: ${params.format}`);
+			const result = await runPythonFile(scriptName, {
+				args: scriptArgs,
+				packages: getPackages(params.format),
+				filePaths: [params.file_path]
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				structuredContent: result
+			};
+		}
+		if (name === "get_document_info") {
+			const params = GetDocumentInfoSchema.parse(args);
+			const fileType = detectFileType(params.file_path);
+			if (!fileType) throw new Error(`Unsupported file type: ${params.file_path}`);
+			let scriptName;
+			let scriptArgs = ["info", params.file_path];
+			if (fileType === "excel") scriptName = "excel_handler.py";
+			else if (fileType === "word") scriptName = "word_handler.py";
+			else if (fileType === "pdf") scriptName = "pdf_handler.py";
+			else scriptName = "text_handler.py";
+			const result = await runPythonFile(scriptName, {
+				args: scriptArgs,
+				packages: getPackages(fileType),
+				filePaths: [params.file_path]
+			});
+			return {
+				content: [{
+					type: "text",
+					text: JSON.stringify(result, null, 2)
+				}],
+				structuredContent: result
+			};
+		}
+		throw new Error(`Unknown tool: ${name}`);
+	} catch (error) {
+		const errorMessage = error instanceof Error ? error.message : String(error);
+		return {
+			content: [{
+				type: "text",
+				text: `Error: ${errorMessage}`
+			}],
+			isError: true
+		};
+	}
+});
+async function main() {
+	const transport = new StdioServerTransport();
+	await server.connect(transport);
+	console.error("Docsmith MCP server running on stdio");
+}
+main().catch((error) => {
+	console.error("Server error:", error);
+	process.exit(1);
+});
+
+//#endregion
+//# sourceMappingURL=index.js.map