docsmith-mcp 0.0.1-beta.1

package/python/word_handler.py

@@ -0,0 +1,98 @@
+"""
+Word document handler - read/write DOCX files
+"""
+import json
+import sys
+from pathlib import Path
+
+def read_word(file_path: str, page: int = None, page_size: int = 100):
+    """Read Word document with optional pagination by paragraphs"""
+    from docx import Document
+    
+    doc = Document(file_path)
+    
+    # Extract paragraphs
+    paragraphs = [p.text for p in doc.paragraphs if p.text.strip()]
+    
+    # Extract tables
+    tables = []
+    for table in doc.tables:
+        table_data = []
+        for row in table.rows:
+            row_data = [cell.text for cell in row.cells]
+            table_data.append(row_data)
+        tables.append(table_data)
+    
+    # Handle pagination for paragraphs
+    if page is not None:
+        start = (page - 1) * page_size
+        end = start + page_size
+        paragraphs = paragraphs[start:end]
+        total_pages = (len(doc.paragraphs) + page_size - 1) // page_size
+    else:
+        total_pages = 1
+    
+    return {
+        "paragraphs": paragraphs,
+        "tables": tables,
+        "total_paragraphs": len(doc.paragraphs),
+        "total_tables": len(doc.tables),
+        "current_page": page,
+        "page_size": page_size if page else None,
+        "total_pages": total_pages
+    }
+
+def get_word_info(file_path: str):
+    """Get Word document metadata"""
+    from docx import Document
+    
+    doc = Document(file_path)
+    
+    # Count non-empty paragraphs
+    para_count = sum(1 for p in doc.paragraphs if p.text.strip())
+    
+    return {
+        "paragraphs": para_count,
+        "tables": len(doc.tables),
+        "file_size": Path(file_path).stat().st_size
+    }
+
+def write_word(file_path: str, paragraphs: list, tables: list = None):
+    """Write data to Word document"""
+    from docx import Document
+    
+    doc = Document()
+    
+    # Add paragraphs
+    for text in paragraphs:
+        doc.add_paragraph(text)
+    
+    # Add tables if provided
+    if tables:
+        for table_data in tables:
+            table = doc.add_table(rows=len(table_data), cols=len(table_data[0]) if table_data else 1)
+            for i, row_data in enumerate(table_data):
+                for j, cell_text in enumerate(row_data):
+                    table.rows[i].cells[j].text = str(cell_text)
+    
+    doc.save(file_path)
+    return {"success": True, "file_path": file_path}
+
+if __name__ == "__main__":
+    command = sys.argv[1]
+    file_path = sys.argv[2]
+    
+    if command == "read":
+        page = int(sys.argv[3]) if len(sys.argv) > 3 else None
+        page_size = int(sys.argv[4]) if len(sys.argv) > 4 else 100
+        result = read_word(file_path, page, page_size)
+    elif command == "info":
+        result = get_word_info(file_path)
+    elif command == "write":
+        paragraphs = json.loads(sys.argv[3])
+        tables = json.loads(sys.argv[4]) if len(sys.argv) > 4 else None
+        result = write_word(file_path, paragraphs, tables)
+    else:
+        result = {"error": f"Unknown command: {command}"}
+    
+    print(json.dumps(result, default=str))

package/scripts/preload-packages.mjs

@@ -0,0 +1,64 @@
+#!/usr/bin/env node
+/**
+ * Preload Python packages during installation
+ * This script runs runPy to install packages into Pyodide's cache
+ *
+ * Note: Requires Node.js with --experimental-wasm-stack-switching flag
+ */
+import { runPy } from "@mcpc-tech/code-runner-mcp";
+
+const PACKAGES = [
+  "openpyxl",
+  "python-docx",
+  "PyPDF2",
+];
+
+async function preloadPackages() {
+  console.log("📦 Preloading Python packages for Pyodide...\n");
+
+  // Use async wrapper to allow await
+  const code = `
+import micropip
+import asyncio
+
+async def main():
+    packages = ${JSON.stringify(PACKAGES)}
+    
+    print(f"Installing {len(packages)} packages...")
+    for pkg in packages:
+        print(f"  - {pkg}")
+    
+    await micropip.install(packages)
+    print("\\n✅ All packages installed successfully!")
+
+asyncio.run(main())
+`;
+
+  try {
+    const stream = await runPy(code, {
+      packages: {
+        openpyxl: "openpyxl",
+        "python-docx": "python-docx",
+        PyPDF2: "PyPDF2",
+      },
+    });
+
+    const reader = stream.getReader();
+    const decoder = new TextDecoder();
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+      const text = decoder.decode(value, { stream: true });
+      process.stdout.write(text);
+    }
+
+    console.log("\n✨ Preload complete!");
+  } catch (error) {
+    console.error("\n❌ Preload failed:", error.message);
+    // Don't fail the install, just warn
+    console.log("⚠️  Packages will be downloaded on first use");
+  }
+}
+
+preloadPackages();

package/src/code-runner.ts

@@ -0,0 +1,136 @@
+/**
+ * Code runner client - uses @mcpc-tech/code-runner-mcp npm package
+ */
+import { runPy, type RunPyOptions } from "@mcpc-tech/code-runner-mcp";
+import { readFileSync } from "fs";
+import { fileURLToPath } from "url";
+import { dirname, join, resolve } from "path";
+
+const __filename = fileURLToPath(import.meta.url);
+const __dirname = dirname(__filename);
+
+/**
+ * Options for running Python script files
+ */
+export interface RunPythonFileOptions {
+  /** Command line arguments to pass to the script */
+  args?: string[];
+  /** Package name mappings (import_name -> pypi_name) */
+  packages?: Record<string, string>;
+  /** Base directory for the script (default: "python") */
+  baseDir?: string;
+  /** User file paths that need to be accessible (for file system mounting) */
+  filePaths?: string[];
+}
+
+/**
+ * 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: string,
+): { mountRoot: string; virtualPath: string } {
+  const absolutePath = resolve(filePath);
+
+  // Mount the parent directory of the file
+  // This allows Python to access the file and its siblings
+  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
+ */
+export async function runPythonFile(
+  scriptPath: string,
+  options: RunPythonFileOptions = {},
+): Promise<any> {
+  const {
+    args = [],
+    packages = {},
+    baseDir = "python",
+    filePaths = [],
+  } = options;
+
+  // Read the Python script
+  const fullPath = join(__dirname, "..", baseDir, scriptPath);
+  const scriptContent = readFileSync(fullPath, "utf-8");
+
+  // Build wrapper code that sets sys.argv and executes the script
+  const wrapperCode = `
+import sys
+import json
+
+# Set command line arguments
+sys.argv = ['${scriptPath}'] + ${JSON.stringify(args)}
+
+# Execute the script
+${scriptContent}
+`;
+
+  // Determine mount root from the first file path
+  let mountRoot = join(__dirname, ".."); // Default: project root
+  if (filePaths.length > 0) {
+    const mapping = getFileSystemMapping(filePaths[0]);
+    mountRoot = mapping.mountRoot;
+  }
+
+  // Execute via runPy with options
+  // Mount point is the same as the mount root (Pyodide will see host paths directly)
+  const runPyOptions: RunPyOptions = {
+    packages,
+    nodeFSMountPoint: mountRoot,
+    nodeFSRoot: mountRoot,
+  };
+  const stream = await runPy(wrapperCode, runPyOptions);
+
+  // Read the stream output
+  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) {
+    // Stream error means Python execution failed
+    return { error: String(streamError) };
+  }
+
+  // Check for errors
+  if (error) {
+    return { error: error.replace(/\[err\]\[py\]\s*/g, "").trim() };
+  }
+
+  // Parse the JSON output from the script (last line)
+  const lines = stdout.trim().split("\n");
+  const lastLine = lines[lines.length - 1];
+
+  try {
+    return JSON.parse(lastLine);
+  } catch {
+    return { stdout, stderr };
+  }
+}