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

package/package.json

@@ -1,9 +1,31 @@
 {
   "name": "docsmith-mcp",
-  "version": "0.0.1-beta.1",
+  "version": "0.0.1-beta.3",
   "description": "Python-powered document processing MCP for Excel, Word, PDF",
   "type": "module",
-  "main": "dist/index.js",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": {
+        "types": "./dist/index.d.ts",
+        "default": "./dist/index.js"
+      },
+      "require": {
+        "types": "./dist/index.d.cts",
+        "default": "./dist/index.cjs"
+      }
+    }
+  },
+  "bin": {
+    "docsmith-mcp": "./dist/index.js"
+  },
+  "files": [
+    "dist",
+    "python",
+    "scripts"
+  ],
   "scripts": {
     "build": "tsdown",
     "dev": "tsdown --watch",

package/python/pptx_handler.py

@@ -0,0 +1,169 @@
+"""
+PowerPoint document handler - read/write PPTX files
+"""
+import json
+import sys
+from pathlib import Path
+
+
+def read_pptx(file_path: str, page: int = None, page_size: int = 100):
+    """Read PowerPoint presentation with optional pagination by slides"""
+    from pptx import Presentation
+    
+    prs = Presentation(file_path)
+    
+    # Extract all slides content
+    slides = []
+    for i, slide in enumerate(prs.slides):
+        slide_data = {
+            "slide_number": i + 1,
+            "title": "",
+            "content": [],
+            "notes": ""
+        }
+        
+        # Extract text from shapes
+        for shape in slide.shapes:
+            if hasattr(shape, "text") and shape.text.strip():
+                # Try to detect if it's a title
+                if hasattr(shape, "is_placeholder") and shape.is_placeholder:
+                    placeholder = shape.placeholder_format
+                    if placeholder.type == 1:  # Title placeholder
+                        slide_data["title"] = shape.text
+                        continue
+                
+                slide_data["content"].append(shape.text)
+            
+            # Extract table data
+            if hasattr(shape, "table"):
+                table_data = []
+                for row in shape.table.rows:
+                    row_data = [cell.text for cell in row.cells]
+                    table_data.append(row_data)
+                slide_data["content"].append({"table": table_data})
+        
+        # Extract notes
+        if slide.has_notes_slide:
+            notes_frame = slide.notes_slide.notes_text_frame
+            if notes_frame:
+                slide_data["notes"] = notes_frame.text
+        
+        slides.append(slide_data)
+    
+    total_slides = len(slides)
+    
+    # Handle pagination
+    if page is not None:
+        start = (page - 1) * page_size
+        end = start + page_size
+        slides = slides[start:end]
+        total_pages = (total_slides + page_size - 1) // page_size if total_slides else 1
+    else:
+        total_pages = 1
+    
+    return {
+        "total_slides": total_slides,
+        "slides": slides,
+        "current_page": page,
+        "page_size": page_size if page else None,
+        "total_pages": total_pages
+    }
+
+
+def get_pptx_info(file_path: str):
+    """Get PowerPoint metadata"""
+    from pptx import Presentation
+    
+    prs = Presentation(file_path)
+    
+    info = {
+        "slides": len(prs.slides),
+        "file_size": Path(file_path).stat().st_size
+    }
+    
+    # Try to get presentation properties
+    if prs.core_properties:
+        props = prs.core_properties
+        metadata = {}
+        if props.title:
+            metadata["title"] = props.title
+        if props.author:
+            metadata["author"] = props.author
+        if props.subject:
+            metadata["subject"] = props.subject
+        if props.created:
+            metadata["created"] = str(props.created)
+        if props.modified:
+            metadata["modified"] = str(props.modified)
+        
+        if metadata:
+            info["metadata"] = metadata
+    
+    return info
+
+
+def write_pptx(file_path: str, slides_data: list):
+    """Write data to PowerPoint presentation"""
+    from pptx import Presentation
+    from pptx.util import Inches, Pt
+    
+    prs = Presentation()
+    prs.slide_width = Inches(10)
+    prs.slide_height = Inches(7.5)
+    
+    for slide_info in slides_data:
+        # Add blank slide
+        blank_layout = prs.slide_layouts[6]  # Blank layout
+        slide = prs.slides.add_slide(blank_layout)
+        
+        # Add title if provided
+        title = slide_info.get("title", "")
+        if title:
+            left = Inches(0.5)
+            top = Inches(0.5)
+            width = Inches(9)
+            height = Inches(1)
+            title_box = slide.shapes.add_textbox(left, top, width, height)
+            title_frame = title_box.text_frame
+            title_frame.text = title
+            title_frame.paragraphs[0].font.size = Pt(32)
+            title_frame.paragraphs[0].font.bold = True
+        
+        # Add content
+        content = slide_info.get("content", [])
+        if content:
+            left = Inches(0.5)
+            top = Inches(2)
+            width = Inches(9)
+            height = Inches(5)
+            content_box = slide.shapes.add_textbox(left, top, width, height)
+            text_frame = content_box.text_frame
+            
+            for item in content:
+                if isinstance(item, str):
+                    p = text_frame.add_paragraph()
+                    p.text = item
+                    p.level = 0
+    
+    prs.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_pptx(file_path, page, page_size)
+    elif command == "info":
+        result = get_pptx_info(file_path)
+    elif command == "write":
+        # Data passed as JSON string
+        slides_data = json.loads(sys.argv[3])
+        result = write_pptx(file_path, slides_data)
+    else:
+        result = {"error": f"Unknown command: {command}"}
+    
+    print(json.dumps(result, default=str))

package/scripts/preload-packages.mjs

@@ -10,6 +10,7 @@ import { runPy } from "@mcpc-tech/code-runner-mcp";
 const PACKAGES = [
   "openpyxl",
   "python-docx",
+  "python-pptx",
   "PyPDF2",
 ];
 
@@ -39,6 +40,7 @@ asyncio.run(main())
       packages: {
         openpyxl: "openpyxl",
         "python-docx": "python-docx",
+        "python-pptx": "python-pptx",
         PyPDF2: "PyPDF2",
       },
     });

package/.github/workflows/test.yml

@@ -1,35 +0,0 @@
-name: Test
-
-on:
-  push:
-    branches: [main, master]
-  pull_request:
-    branches: [main, master]
-
-jobs:
-  test:
-    runs-on: ubuntu-latest
-
-    steps:
-      - name: Checkout code
-        uses: actions/checkout@v4
-
-      - name: Setup pnpm
-        uses: pnpm/action-setup@v2
-        with:
-          version: 9
-
-      - name: Setup Node.js
-        uses: actions/setup-node@v4
-        with:
-          node-version: 24
-          cache: "pnpm"
-
-      - name: Install dependencies
-        run: pnpm install --frozen-lockfile
-
-      - name: Run tests
-        run: pnpm test:run
-
-      - name: Build
-        run: pnpm build

package/dist/python/excel_handler.py

@@ -1,97 +0,0 @@
-"""
-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/dist/python/pdf_handler.py

@@ -1,81 +0,0 @@
-"""
-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))