docsmith-mcp 0.0.1-beta.1 → 0.0.1-beta.3

package/dist/index.cjs

@@ -0,0 +1,750 @@
+#!/usr/bin/env node
+"use strict";
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+
+//#endregion
+const __modelcontextprotocol_sdk_server_index_js = __toESM(require("@modelcontextprotocol/sdk/server/index.js"));
+const __modelcontextprotocol_sdk_server_stdio_js = __toESM(require("@modelcontextprotocol/sdk/server/stdio.js"));
+const __modelcontextprotocol_sdk_types_js = __toESM(require("@modelcontextprotocol/sdk/types.js"));
+const zod = __toESM(require("zod"));
+const __mcpc_tech_code_runner_mcp = __toESM(require("@mcpc-tech/code-runner-mcp"));
+const fs = __toESM(require("fs"));
+const url = __toESM(require("url"));
+const path = __toESM(require("path"));
+
+//#region src/code-runner.ts
+const __filename$1 = (0, url.fileURLToPath)(require("url").pathToFileURL(__filename).href);
+const __dirname$1 = (0, path.dirname)(__filename$1);
+/**
+* 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 = (0, path.resolve)(filePath);
+	const mountRoot = (0, path.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 = (0, path.join)(__dirname$1, "..", baseDir, scriptPath);
+	const scriptContent = (0, fs.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 = (0, path.join)(__dirname$1, "..");
+	if (filePaths.length > 0) {
+		const mapping = getFileSystemMapping(filePaths[0]);
+		mountRoot = mapping.mountRoot;
+	}
+	const runPyOptions = {
+		packages,
+		nodeFSMountPoint: mountRoot,
+		nodeFSRoot: mountRoot
+	};
+	const stream = await (0, __mcpc_tech_code_runner_mcp.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 === "pptx" || ext === "ppt") return "pptx";
+	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" },
+		pptx: { pptx: "python-pptx" },
+		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 = zod.z.object({
+	file_path: zod.z.string().describe("Absolute path to the document file"),
+	file_type: zod.z.enum([
+		"excel",
+		"word",
+		"pptx",
+		"pdf",
+		"text"
+	]).optional().describe("Override file type detection. Use this to explicitly specify the format instead of relying on file extension"),
+	mode: zod.z.enum(["raw", "paginated"]).optional().describe("Read mode: 'raw' for full content, 'paginated' for chunked reading"),
+	page: zod.z.number().optional().describe("Page number for paginated mode (1-based)"),
+	page_size: zod.z.number().optional().describe("Items per page for paginated mode"),
+	sheet_name: zod.z.string().optional().describe("Sheet name for Excel files")
+});
+const WriteDocumentSchema = zod.z.object({
+	file_path: zod.z.string().describe("Absolute path to save the document"),
+	format: zod.z.enum([
+		"excel",
+		"word",
+		"pptx",
+		"text"
+	]).describe("Document format"),
+	data: zod.z.any().describe("Document data structure")
+});
+const GetDocumentInfoSchema = zod.z.object({
+	file_path: zod.z.string().describe("Absolute path to the document file"),
+	file_type: zod.z.enum([
+		"excel",
+		"word",
+		"pptx",
+		"pdf",
+		"text"
+	]).optional().describe("Override file type detection. Use this to explicitly specify the format instead of relying on file extension")
+});
+const server = new __modelcontextprotocol_sdk_server_index_js.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 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 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(__modelcontextprotocol_sdk_types_js.ListToolsRequestSchema, async () => {
+	return { tools: [
+		{
+			name: "read_document",
+			description: "Read document content (Excel, Word, PowerPoint, 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"
+					},
+					file_type: {
+						type: "string",
+						enum: [
+							"excel",
+							"word",
+							"pptx",
+							"pdf",
+							"text"
+						],
+						description: "Override file type detection (optional). Specify format explicitly instead of relying on extension"
+					},
+					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: "Document content with format-specific structure. Common fields: success (boolean), error (string, on failure).",
+				properties: {
+					success: { type: "boolean" },
+					error: { type: "string" },
+					encoding: { type: "string" },
+					sheet_name: { type: "string" },
+					sheets: {
+						type: "array",
+						items: { type: "string" }
+					},
+					total_rows: { type: "number" },
+					total_cols: { type: "number" },
+					current_page: { type: ["number", "null"] },
+					total_pages: { type: "number" },
+					paragraphs: { type: "array" },
+					tables: { type: "array" },
+					total_paragraphs: { type: "number" },
+					total_tables: { type: "number" },
+					total_slides: { type: "number" },
+					slides: {
+						type: "array",
+						items: {
+							type: "object",
+							properties: {
+								slide_number: { type: "number" },
+								title: { type: "string" },
+								content: { type: "array" },
+								notes: { type: "string" }
+							}
+						}
+					},
+					current_page_group: { type: ["number", "null"] },
+					total_page_groups: { type: "number" },
+					content: {},
+					total_lines: { type: "number" },
+					headers: {
+						type: "array",
+						items: { type: "string" }
+					},
+					data: {},
+					page: { type: "number" },
+					page_size: { type: ["number", "null"] },
+					has_more: { type: "boolean" }
+				},
+				additionalProperties: false
+			}
+		},
+		{
+			name: "write_document",
+			description: "Write document content (Excel, Word, PowerPoint, Text)",
+			inputSchema: {
+				type: "object",
+				properties: {
+					file_path: {
+						type: "string",
+						description: "Absolute path to save the document"
+					},
+					format: {
+						type: "string",
+						enum: [
+							"excel",
+							"word",
+							"pptx",
+							"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, slide count, file size, etc.)",
+			inputSchema: {
+				type: "object",
+				properties: {
+					file_path: {
+						type: "string",
+						description: "Absolute path to the document file"
+					},
+					file_type: {
+						type: "string",
+						enum: [
+							"excel",
+							"word",
+							"pptx",
+							"pdf",
+							"text"
+						],
+						description: "Override file type detection (optional). Specify format explicitly instead of relying on extension"
+					}
+				},
+				required: ["file_path"]
+			},
+			outputSchema: {
+				type: "object",
+				description: "Document metadata with format-specific fields",
+				properties: {
+					success: { type: "boolean" },
+					error: { type: "string" },
+					file_size: { type: "number" },
+					sheets: {
+						type: "array",
+						items: {
+							type: "object",
+							properties: {
+								name: { type: "string" },
+								rows: { type: "number" },
+								cols: { type: "number" }
+							}
+						}
+					},
+					paragraphs: { type: "number" },
+					tables: { type: "number" },
+					slides: { type: "number" },
+					pages: { type: "number" },
+					total_words: { type: "number" },
+					metadata: { type: "object" },
+					line_count: { type: "number" },
+					encoding: { type: "string" },
+					file_type: { type: "string" },
+					headers: {
+						type: "array",
+						items: { type: "string" }
+					},
+					total_rows: { type: "number" },
+					total_cols: { type: "number" },
+					item_count: { type: "number" },
+					key_count: { type: "number" }
+				},
+				additionalProperties: false
+			}
+		}
+	] };
+});
+server.setRequestHandler(__modelcontextprotocol_sdk_types_js.CallToolRequestSchema, async (request) => {
+	const { name, arguments: args } = request.params;
+	try {
+		if (name === "read_document") {
+			const params = ReadDocumentSchema.parse(args);
+			const fileType = params.file_type || 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 === "pptx") {
+				scriptName = "pptx_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 === "pptx") {
+				scriptName = "pptx_handler.py";
+				const slides = params.data.slides || params.data || [];
+				scriptArgs = [
+					"write",
+					params.file_path,
+					JSON.stringify(slides)
+				];
+			} 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 = params.file_type || 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 === "pptx") scriptName = "pptx_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 __modelcontextprotocol_sdk_server_stdio_js.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.cjs.map