docsmith-mcp 0.0.1-beta.1

package/examples/sample_data.csv

@@ -0,0 +1,6 @@
+Name,Age,City
+Alice,30,New York
+Bob,25,Los Angeles
+Charlie,35,Chicago
+Diana,28,Miami
+Eve,32,Seattle

package/examples/sample_data.json

@@ -0,0 +1,9 @@
+{
+  "users": [
+    { "id": 1, "name": "Alice", "email": "alice@example.com" },
+    { "id": 2, "name": "Bob", "email": "bob@example.com" },
+    { "id": 3, "name": "Charlie", "email": "charlie@example.com" }
+  ],
+  "total": 3,
+  "page": 1
+}

package/examples/sample_document.pdf

@@ -0,0 +1,80 @@
+%PDF-1.4
+%���� ReportLab Generated PDF document (opensource)
+1 0 obj
+<<
+/F1 2 0 R /F2 3 0 R /F3 4 0 R
+>>
+endobj
+2 0 obj
+<<
+/BaseFont /Helvetica /Encoding /WinAnsiEncoding /Name /F1 /Subtype /Type1 /Type /Font
+>>
+endobj
+3 0 obj
+<<
+/BaseFont /Helvetica-Bold /Encoding /WinAnsiEncoding /Name /F2 /Subtype /Type1 /Type /Font
+>>
+endobj
+4 0 obj
+<<
+/BaseFont /Helvetica-BoldOblique /Encoding /WinAnsiEncoding /Name /F3 /Subtype /Type1 /Type /Font
+>>
+endobj
+5 0 obj
+<<
+/Contents 9 0 R /MediaBox [ 0 0 612 792 ] /Parent 8 0 R /Resources <<
+/Font 1 0 R /ProcSet [ /PDF /Text /ImageB /ImageC /ImageI ]
+>> /Rotate 0 /Trans <<
+
+>> 
+  /Type /Page
+>>
+endobj
+6 0 obj
+<<
+/PageMode /UseNone /Pages 8 0 R /Type /Catalog
+>>
+endobj
+7 0 obj
+<<
+/Author (\(anonymous\)) /CreationDate (D:20260202143317+08'00') /Creator (\(unspecified\)) /Keywords () /ModDate (D:20260202143317+08'00') /Producer (ReportLab PDF Library - \(opensource\)) 
+  /Subject (\(unspecified\)) /Title (\(anonymous\)) /Trapped /False
+>>
+endobj
+8 0 obj
+<<
+/Count 1 /Kids [ 5 0 R ] /Type /Pages
+>>
+endobj
+9 0 obj
+<<
+/Filter [ /ASCII85Decode /FlateDecode ] /Length 1245
+>>
+stream
+Gat=*a`?,q&A@B[qCj@6@N3-MJE/FV3LNI/b/@=\/p"j*O9f&9'J<FVYFc"Xb;(MJ/=&]&q1*qXDPA3TMAL&WP76C*!oA<4^c3lG^]G.aiY!jZZQD!S+i=RbbRodl_Dm`/#/\8+&.F@/rWC,cL't7pm;lMb_hC,?^b<pB?^<E<"HDpH@L;Y8H!]eG>a_]E.c?Q75@JO6Mq;qI#`*$*iUrR7&/+(R*SOY/s"U:.ooN;&o3r.^(3s6XpFb4cr#Yhl`QAp`c4^:emn@_6c)rEO8qZtj4f';Hg=iH<Y`8qmSi/^"prjPR/O?jc.GD:rFdD:/r\>e0\q$SfH;_V'O)(!rY$S$/DW=:G]7Er=):1ric(/#2S!]OcS_KE(FC%7F2l<Z]DS4:A/tH'%YKa@mZnC.:8tda,NCbU$gll6!OD6<c18)[>d+*phMQ_lQB6+Sj9NB`@4R/%Z&fpgZN+)Pb*k%,ien^:%iYY&t+o%R_(iWTjSrm,P`56JS'Ft<!cNne\"%O"\\pM'FVUkN0Nc?_!6')+52GmB^o6/`4S)+7Q:ln5J*f=)1`dqAl_B/g?3)BlQ_Dph3mo,d\boUskB8;1eYR*cQO>:_)\\`C),+@4S5ZB:]llV18RFm3m,j'G=:?2OWLmUTh!'TH7eMn,$%*Wb-)V@Keh7.fAasj'PA(?4"Uf5*qKF]b3-X]*V%X0D@1rVuc(MuWVHoWu]9N(Mfm(r7O:3l#[&NTp01\i$8%XBPg'MV#``/$@VCL,V6V3B'5I#;W/=PVr3WVg]]L`BeWT7DcK'/b#!%JO<1,l!&MS$%(@52r2?s/K_fX,Fk)>W5\E)!N7aI/rr$7qUcncs(MB>@fKjES+KL)QYpbXk8,L.h5c6$\HBh^CSW"n/]K;gX-*dVL!R5W-e%$l%p9S7JOqQ/[/CJh`n%=ZKlUbhs0D[/Q=^l'(bk1_h7+H0@g_?l8h^=lqmh)Z\*,RQ??*A`ocDCO$LA)j2Ff1\4cHr3NP70'`7F&H"Pg`CL6/kD:c&On*@0m6V;>A;cHK;5'Y&<H=cUS]mb/cS@h3HJ>;+I]?uHq!PQt$nu+d;5@]*`S*b212I97IcJ@3%%3JjFS7d?@NX7?[YSRU!e4U^l\bVZG$=g:>o2;S\%CiNA@<HH<lX`t/oFc!.<L,t:APjUrYuFbX6fKUtkK>2FNM+._nO`>K@rulPBWte.ChGYqo;sOFT7A%`F*eh,XHUSeXYO\"fV&:tg&I\b^(p~>endstream
+endobj
+xref
+0 10
+0000000000 65535 f 
+0000000061 00000 n 
+0000000112 00000 n 
+0000000219 00000 n 
+0000000331 00000 n 
+0000000450 00000 n 
+0000000643 00000 n 
+0000000711 00000 n 
+0000000991 00000 n 
+0000001050 00000 n 
+trailer
+<<
+/ID 
+[<72e692cf8a12e2d98cf221bdbcb57649><72e692cf8a12e2d98cf221bdbcb57649>]
+% ReportLab generated PDF document -- digest (opensource)
+
+/Info 7 0 R
+/Root 6 0 R
+/Size 10
+>>
+startxref
+2386
+%%EOF

package/examples/sample_text.txt

@@ -0,0 +1,10 @@
+This is a sample text file.
+It has multiple lines.
+Line 3 here.
+Line 4 here.
+Line 5 here.
+Line 6 here.
+Line 7 here.
+Line 8 here.
+Line 9 here.
+Line 10 here.

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "docsmith-mcp",
+  "version": "0.0.1-beta.1",
+  "description": "Python-powered document processing MCP for Excel, Word, PDF",
+  "type": "module",
+  "main": "dist/index.js",
+  "scripts": {
+    "build": "tsdown",
+    "dev": "tsdown --watch",
+    "prepare": "pnpm build",
+    "postinstall": "node --experimental-wasm-stack-switching scripts/preload-packages.mjs || true",
+    "test": "vitest",
+    "test:run": "vitest run",
+    "test:ui": "vitest --ui"
+  },
+  "keywords": [
+    "mcp",
+    "document",
+    "excel",
+    "word",
+    "pdf"
+  ],
+  "author": "",
+  "license": "MIT",
+  "dependencies": {
+    "@mcpc-tech/code-runner-mcp": "0.1.8",
+    "@modelcontextprotocol/sdk": "^1.25.3",
+    "zod": "3"
+  },
+  "devDependencies": {
+    "@vitest/ui": "^4.0.18",
+    "tsdown": "^0.9.0",
+    "typescript": "^5.7.0",
+    "vitest": "^4.0.18"
+  }
+}

package/python/excel_handler.py

@@ -0,0 +1,97 @@
+"""
+Excel document handler - read/write Excel files
+"""
+import json
+import sys
+from pathlib import Path
+
+def read_excel(file_path: str, sheet_name: str = None, page: int = None, page_size: int = 100):
+    """Read Excel file with optional pagination"""
+    import openpyxl
+    
+    wb = openpyxl.load_workbook(file_path, data_only=True)
+    
+    if sheet_name is None:
+        sheet_name = wb.sheetnames[0]
+    
+    ws = wb[sheet_name]
+    
+    # Get all data
+    data = []
+    for row in ws.iter_rows(values_only=True):
+        data.append(row)
+    
+    # Handle pagination
+    if page is not None:
+        start = (page - 1) * page_size
+        end = start + page_size
+        data = data[start:end]
+        total_pages = (len(data) + page_size - 1) // page_size if data else 1
+    else:
+        total_pages = 1
+    
+    return {
+        "sheet_name": sheet_name,
+        "sheets": wb.sheetnames,
+        "total_rows": ws.max_row,
+        "total_cols": ws.max_column,
+        "current_page": page,
+        "page_size": page_size if page else None,
+        "total_pages": total_pages,
+        "data": data
+    }
+
+def get_excel_info(file_path: str):
+    """Get Excel file metadata"""
+    import openpyxl
+    
+    wb = openpyxl.load_workbook(file_path, data_only=True)
+    info = {
+        "sheets": [],
+        "file_size": Path(file_path).stat().st_size
+    }
+    
+    for sheet_name in wb.sheetnames:
+        ws = wb[sheet_name]
+        info["sheets"].append({
+            "name": sheet_name,
+            "rows": ws.max_row,
+            "cols": ws.max_column
+        })
+    
+    return info
+
+def write_excel(file_path: str, data: list, sheet_name: str = "Sheet1"):
+    """Write data to Excel file"""
+    import openpyxl
+    
+    wb = openpyxl.Workbook()
+    ws = wb.active
+    ws.title = sheet_name
+    
+    for row in data:
+        ws.append(row)
+    
+    wb.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":
+        sheet = sys.argv[3] if len(sys.argv) > 3 else None
+        page = int(sys.argv[4]) if len(sys.argv) > 4 else None
+        page_size = int(sys.argv[5]) if len(sys.argv) > 5 else 100
+        result = read_excel(file_path, sheet, page, page_size)
+    elif command == "info":
+        result = get_excel_info(file_path)
+    elif command == "write":
+        # Data passed as JSON string
+        data = json.loads(sys.argv[3])
+        sheet = sys.argv[4] if len(sys.argv) > 4 else "Sheet1"
+        result = write_excel(file_path, data, sheet)
+    else:
+        result = {"error": f"Unknown command: {command}"}
+    
+    print(json.dumps(result, default=str))

package/python/pdf_handler.py

@@ -0,0 +1,81 @@
+"""
+PDF document handler - read PDF files using PyPDF2
+"""
+import json
+import sys
+from pathlib import Path
+
+def read_pdf(file_path: str, page: int = None, page_size: int = 100):
+    """Read PDF with optional pagination by pages"""
+    from PyPDF2 import PdfReader
+    
+    reader = PdfReader(file_path)
+    total_pages = len(reader.pages)
+    
+    # Handle pagination
+    if page is not None:
+        start_page = (page - 1) * page_size
+        end_page = min(start_page + page_size, total_pages)
+        pages_to_read = range(start_page, end_page)
+        current_page = page
+        total_page_groups = (total_pages + page_size - 1) // page_size
+    else:
+        pages_to_read = range(total_pages)
+        current_page = None
+        total_page_groups = 1
+    
+    content = []
+    for i in pages_to_read:
+        page_obj = reader.pages[i]
+        text = page_obj.extract_text()
+        content.append({
+            "page_number": i + 1,
+            "text": text or "",
+            "words": len(text.split()) if text else 0
+        })
+    
+    return {
+        "total_pages": total_pages,
+        "current_page_group": current_page,
+        "page_size": page_size if page else None,
+        "total_page_groups": total_page_groups,
+        "content": content
+    }
+
+def get_pdf_info(file_path: str):
+    """Get PDF metadata"""
+    from PyPDF2 import PdfReader
+    
+    reader = PdfReader(file_path)
+    info = {
+        "pages": len(reader.pages),
+        "file_size": Path(file_path).stat().st_size
+    }
+    
+    # Try to get PDF metadata
+    if reader.metadata:
+        info["metadata"] = {k: str(v) for k, v in reader.metadata.items()}
+    
+    # Count total words
+    total_words = 0
+    for page in reader.pages:
+        text = page.extract_text() or ""
+        total_words += len(text.split())
+    info["total_words"] = total_words
+    
+    return info
+
+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 10
+        result = read_pdf(file_path, page, page_size)
+    elif command == "info":
+        result = get_pdf_info(file_path)
+    else:
+        result = {"error": f"Unknown command: {command}"}
+    
+    print(json.dumps(result, default=str))

package/python/text_handler.py

@@ -0,0 +1,331 @@
+#!/usr/bin/env python3
+"""
+Text file handler - supports .txt, .csv, .md, .json, .yaml, .yml
+Provides structured parsing for CSV and JSON files
+"""
+
+import sys
+import json
+import os
+import csv
+from io import StringIO
+
+
+def detect_file_type(file_path):
+    """Detect file type from extension."""
+    ext = file_path.lower().split('.')[-1] if '.' in file_path else ''
+    return ext
+
+
+def read_text(file_path, page=None, page_size=None):
+    """Read text file with optional pagination."""
+    try:
+        # Detect encoding
+        encodings = ['utf-8', 'utf-8-sig', 'gbk', 'gb2312', 'latin-1']
+        content = None
+        used_encoding = None
+        
+        for encoding in encodings:
+            try:
+                with open(file_path, 'r', encoding=encoding) as f:
+                    content = f.read()
+                used_encoding = encoding
+                break
+            except UnicodeDecodeError:
+                continue
+        
+        if content is None:
+            raise Exception("Could not decode file with any supported encoding")
+        
+        lines = content.split('\n')
+        total_lines = len(lines)
+        
+        # Pagination
+        if page is not None and page_size is not None:
+            start = (page - 1) * page_size
+            end = start + page_size
+            paginated_lines = lines[start:end]
+            has_more = end < total_lines
+            
+            return {
+                "success": True,
+                "content": '\n'.join(paginated_lines),
+                "total_lines": total_lines,
+                "page": page,
+                "page_size": page_size,
+                "has_more": has_more,
+                "encoding": used_encoding
+            }
+        else:
+            return {
+                "success": True,
+                "content": content,
+                "total_lines": total_lines,
+                "encoding": used_encoding
+            }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def read_csv(file_path, page=None, page_size=None):
+    """Read CSV file and return structured data."""
+    try:
+        encodings = ['utf-8', 'utf-8-sig', 'gbk', 'gb2312', 'latin-1']
+        content = None
+        used_encoding = None
+        
+        for encoding in encodings:
+            try:
+                with open(file_path, 'r', encoding=encoding) as f:
+                    content = f.read()
+                used_encoding = encoding
+                break
+            except UnicodeDecodeError:
+                continue
+        
+        if content is None:
+            raise Exception("Could not decode file with any supported encoding")
+        
+        # Parse CSV
+        reader = csv.reader(StringIO(content))
+        rows = list(reader)
+        
+        if not rows:
+            return {
+                "success": True,
+                "headers": [],
+                "data": [],
+                "total_rows": 0,
+                "encoding": used_encoding
+            }
+        
+        headers = rows[0]
+        data_rows = rows[1:]
+        total_rows = len(data_rows)
+        
+        # Convert to list of dicts
+        structured_data = []
+        for row in data_rows:
+            row_dict = {}
+            for i, header in enumerate(headers):
+                row_dict[header] = row[i] if i < len(row) else ""
+            structured_data.append(row_dict)
+        
+        # Pagination
+        if page is not None and page_size is not None:
+            start = (page - 1) * page_size
+            end = start + page_size
+            paginated_data = structured_data[start:end]
+            has_more = end < total_rows
+            
+            return {
+                "success": True,
+                "headers": headers,
+                "data": paginated_data,
+                "total_rows": total_rows,
+                "page": page,
+                "page_size": page_size,
+                "has_more": has_more,
+                "encoding": used_encoding
+            }
+        else:
+            return {
+                "success": True,
+                "headers": headers,
+                "data": structured_data,
+                "total_rows": total_rows,
+                "encoding": used_encoding
+            }
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def read_json(file_path):
+    """Read JSON file and return parsed object."""
+    try:
+        encodings = ['utf-8', 'utf-8-sig', 'gbk', 'gb2312', 'latin-1']
+        content = None
+        used_encoding = None
+        
+        for encoding in encodings:
+            try:
+                with open(file_path, 'r', encoding=encoding) as f:
+                    content = f.read()
+                used_encoding = encoding
+                break
+            except UnicodeDecodeError:
+                continue
+        
+        if content is None:
+            raise Exception("Could not decode file with any supported encoding")
+        
+        parsed = json.loads(content)
+        
+        return {
+            "success": True,
+            "data": parsed,
+            "encoding": used_encoding
+        }
+    except json.JSONDecodeError as e:
+        return {"success": False, "error": f"Invalid JSON: {str(e)}"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def write_text(file_path, content):
+    """Write content to text file."""
+    try:
+        with open(file_path, 'w', encoding='utf-8') as f:
+            f.write(content)
+        return {"success": True, "message": "File written successfully"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def write_csv(file_path, data):
+    """Write data to CSV file."""
+    try:
+        if isinstance(data, str):
+            data = json.loads(data)
+        
+        with open(file_path, 'w', encoding='utf-8', newline='') as f:
+            if data and len(data) > 0:
+                writer = csv.DictWriter(f, fieldnames=data[0].keys())
+                writer.writeheader()
+                writer.writerows(data)
+        return {"success": True, "message": "CSV file written successfully"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def write_json(file_path, data):
+    """Write data to JSON file."""
+    try:
+        if isinstance(data, str):
+            data = json.loads(data)
+        
+        with open(file_path, 'w', encoding='utf-8') as f:
+            json.dump(data, f, ensure_ascii=False, indent=2)
+        return {"success": True, "message": "JSON file written successfully"}
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def get_info(file_path):
+    """Get text file metadata."""
+    try:
+        stat = os.stat(file_path)
+        file_type = detect_file_type(file_path)
+        
+        # Try to detect encoding and count lines
+        encodings = ['utf-8', 'utf-8-sig', 'gbk', 'gb2312', 'latin-1']
+        line_count = 0
+        encoding = None
+        
+        for enc in encodings:
+            try:
+                with open(file_path, 'r', encoding=enc) as f:
+                    content = f.read()
+                    line_count = len(content.split('\n'))
+                encoding = enc
+                break
+            except UnicodeDecodeError:
+                continue
+        
+        result = {
+            "success": True,
+            "file_size": stat.st_size,
+            "line_count": line_count,
+            "encoding": encoding or "unknown",
+            "file_type": file_type
+        }
+        
+        # Add type-specific info
+        if file_type == 'csv':
+            try:
+                with open(file_path, 'r', encoding=encoding or 'utf-8') as f:
+                    reader = csv.reader(f)
+                    rows = list(reader)
+                    if rows:
+                        result['headers'] = rows[0]
+                        result['total_rows'] = len(rows) - 1
+                        result['total_cols'] = len(rows[0])
+            except:
+                pass
+        elif file_type == 'json':
+            try:
+                with open(file_path, 'r', encoding=encoding or 'utf-8') as f:
+                    data = json.load(f)
+                    if isinstance(data, list):
+                        result['item_count'] = len(data)
+                    elif isinstance(data, dict):
+                        result['key_count'] = len(data.keys())
+            except:
+                pass
+        
+        return result
+    except Exception as e:
+        return {"success": False, "error": str(e)}
+
+
+def main():
+    if len(sys.argv) < 2:
+        print(json.dumps({"success": False, "error": "No command specified"}))
+        return
+    
+    command = sys.argv[1]
+    
+    if command == "read":
+        if len(sys.argv) < 3:
+            print(json.dumps({"success": False, "error": "No file path specified"}))
+            return
+        
+        file_path = sys.argv[2]
+        page = int(sys.argv[3]) if len(sys.argv) > 3 else None
+        page_size = int(sys.argv[4]) if len(sys.argv) > 4 else None
+        
+        file_type = detect_file_type(file_path)
+        
+        if file_type == 'csv':
+            result = read_csv(file_path, page, page_size)
+        elif file_type == 'json':
+            result = read_json(file_path)
+        else:
+            result = read_text(file_path, page, page_size)
+        
+        print(json.dumps(result))
+    
+    elif command == "write":
+        if len(sys.argv) < 4:
+            print(json.dumps({"success": False, "error": "Insufficient arguments"}))
+            return
+        
+        file_path = sys.argv[2]
+        content = sys.argv[3]
+        
+        file_type = detect_file_type(file_path)
+        
+        if file_type == 'csv':
+            result = write_csv(file_path, content)
+        elif file_type == 'json':
+            result = write_json(file_path, content)
+        else:
+            result = write_text(file_path, content)
+        
+        print(json.dumps(result))
+    
+    elif command == "info":
+        if len(sys.argv) < 3:
+            print(json.dumps({"success": False, "error": "No file path specified"}))
+            return
+        
+        file_path = sys.argv[2]
+        result = get_info(file_path)
+        print(json.dumps(result))
+    
+    else:
+        print(json.dumps({"success": False, "error": f"Unknown command: {command}"}))
+
+
+if __name__ == "__main__":
+    main()