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

package/dist/python/text_handler.py

@@ -1,331 +0,0 @@
-#!/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()

package/dist/python/word_handler.py

@@ -1,98 +0,0 @@
-"""
-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/examples/sample_data.csv

@@ -1,6 +0,0 @@
-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

@@ -1,9 +0,0 @@
-{
-  "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

@@ -1,80 +0,0 @@
-%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

@@ -1,10 +0,0 @@
-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/src/code-runner.ts

@@ -1,136 +0,0 @@
-/**
- * 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 };
-  }
-}