@larkup/tool-doc-editor 0.2.0

package/dist/sandbox-scripts.js

@@ -0,0 +1,359 @@
+/**
+ * Python code templates for sandbox-based document editing.
+ *
+ * These scripts run inside the Docker sandbox with:
+ * - pypdf: PDF form field filling
+ * - python-docx: Word document editing
+ * - python-pptx: PowerPoint editing
+ * - Pillow: Image processing
+ *
+ * All scripts expect input files in /sandbox/input/ and output to /sandbox/output/
+ */
+/* ------------------------------------------------------------------ */
+/* PDF — Fill form fields using pypdf                                  */
+/* ------------------------------------------------------------------ */
+export function generateFillPDFScript(edits) {
+    const editsJson = JSON.stringify(edits);
+    return `
+import json
+import sys
+from pypdf import PdfReader, PdfWriter
+
+# Load the PDF
+reader = PdfReader("/sandbox/input/document.pdf")
+writer = PdfWriter()
+
+# Copy all pages
+for page in reader.pages:
+    writer.add_page(page)
+
+# Copy existing form fields
+if reader.is_form:
+    writer.clone_reader_document_root(reader)
+
+# Parse edits
+edits = json.loads('''${editsJson}''')
+
+# Build field value map (field_name -> value)
+field_map = {}
+for edit in edits:
+    field_map[edit["fieldId"]] = edit["value"]
+
+# Apply form field fills
+if reader.is_form:
+    fields = reader.get_fields()
+    update_dict = {}
+    for field_name, field_obj in (fields or {}).items():
+        for edit_id, value in field_map.items():
+            # Match by name or by detected ID pattern
+            if field_name == edit_id or edit_id.endswith(field_name):
+                update_dict[field_name] = value
+                break
+
+    if update_dict:
+        writer.update_page_form_field_values(writer.pages[0], update_dict)
+
+# Save
+with open("/sandbox/output/document.pdf", "wb") as f:
+    writer.write(f)
+
+print(f"SUCCESS: Updated {len(field_map)} fields")
+`;
+}
+/* ------------------------------------------------------------------ */
+/* PDF — Extract full text using pypdf                                 */
+/* ------------------------------------------------------------------ */
+export function generateExtractPDFTextScript() {
+    return `
+import json
+from pypdf import PdfReader
+
+reader = PdfReader("/sandbox/input/document.pdf")
+pages = []
+fields = []
+
+for i, page in enumerate(reader.pages):
+    text = page.extract_text() or ""
+    pages.append({
+        "index": i,
+        "text": text,
+    })
+    
+    # Smart signature detection
+    lines = text.split('\\n')
+    for line in lines:
+        lower_line = line.lower()
+        if "signature:" in lower_line or "sign here" in lower_line or "date:" in lower_line or "_______" in lower_line:
+            if "signature" in lower_line or "sign" in lower_line:
+                fields.append({
+                    "name": "detected_signature_" + str(i),
+                    "type": "signature_placeholder",
+                    "value": "",
+                    "pageIndex": i,
+                    "context": line.strip()
+                })
+
+# Extract form fields
+if reader.is_form:
+    form_fields = reader.get_fields() or {}
+    for name, field in form_fields.items():
+        field_type = str(field.get("/FT", ""))
+        value = str(field.get("/V", ""))
+        fields.append({
+            "name": name,
+            "type": field_type,
+            "value": value,
+            "pageIndex": 0 # We might not know the exact page from get_fields easily, default to 0
+        })
+
+result = {
+    "pages": pages,
+    "fields": fields,
+    "totalPages": len(reader.pages),
+    "metadata": dict(reader.metadata or {}),
+}
+
+print("__RESULT__:" + json.dumps(result, default=str))
+`;
+}
+/* ------------------------------------------------------------------ */
+/* DOCX — Edit content using python-docx                               */
+/* ------------------------------------------------------------------ */
+export function generateEditDOCXScript(edits) {
+    const editsJson = JSON.stringify(edits);
+    return `
+import json
+from docx import Document
+
+doc = Document("/sandbox/input/document.docx")
+edits = json.loads('''${editsJson}''')
+
+updated = 0
+for edit in edits:
+    edit_type = edit.get("type", "replace_text")
+
+    if edit_type == "replace_text":
+        search = edit.get("search", "")
+        replacement = edit.get("text", "")
+
+        for para in doc.paragraphs:
+            if search in para.text:
+                # Preserve formatting by replacing in runs
+                full_text = ""
+                for run in para.runs:
+                    full_text += run.text
+
+                if search in full_text:
+                    # Simple replacement — replace in runs
+                    remaining = search
+                    for run in para.runs:
+                        if remaining and remaining in run.text:
+                            run.text = run.text.replace(remaining, replacement, 1)
+                            remaining = ""
+                            updated += 1
+                            break
+                        elif remaining and run.text and remaining.startswith(run.text):
+                            remaining = remaining[len(run.text):]
+                            run.text = ""
+
+        # Also check tables
+        for table in doc.tables:
+            for row in table.rows:
+                for cell in row.cells:
+                    for para in cell.paragraphs:
+                        if search in para.text:
+                            for run in para.runs:
+                                if search in run.text:
+                                    run.text = run.text.replace(search, replacement, 1)
+                                    updated += 1
+
+    elif edit_type == "insert_text":
+        text = edit.get("text", "")
+        position = edit.get("position", len(doc.paragraphs))
+        if position < len(doc.paragraphs):
+            para = doc.paragraphs[position]
+            para.insert_paragraph_before(text)
+        else:
+            doc.add_paragraph(text)
+        updated += 1
+
+doc.save("/sandbox/output/document.docx")
+print(f"SUCCESS: Applied {updated} edits")
+`;
+}
+/* ------------------------------------------------------------------ */
+/* DOCX — Fill form fields (content controls / placeholder text)       */
+/* ------------------------------------------------------------------ */
+export function generateFillDOCXScript(edits) {
+    const editsJson = JSON.stringify(edits);
+    return `
+import json
+from docx import Document
+
+doc = Document("/sandbox/input/document.docx")
+edits = json.loads('''${editsJson}''')
+
+# Build lookup
+field_map = {edit["fieldId"]: edit["value"] for edit in edits}
+
+updated = 0
+
+# Strategy 1: Look for common form patterns like "Label: ___" or "Label: "
+for para in doc.paragraphs:
+    for field_id, value in field_map.items():
+        # The field_id contains the label name from detection
+        label = field_id.replace("detected_", "").strip()
+        
+        # Check if paragraph contains "Label:" pattern
+        text = para.text
+        for run in para.runs:
+            if "___" in run.text or (run.text.strip().endswith(":") and not value):
+                # Replace underscores with value
+                run.text = run.text.replace("___", value).rstrip("_")
+                updated += 1
+
+# Strategy 2: Check tables (common in forms)
+for table in doc.tables:
+    for row in table.rows:
+        cells = row.cells
+        for i, cell in enumerate(cells):
+            cell_text = cell.text.strip().rstrip(":")
+            # If this cell's text matches a field name, fill the next cell
+            for field_id, value in field_map.items():
+                if cell_text.lower() == field_id.lower() and i + 1 < len(cells):
+                    next_cell = cells[i + 1]
+                    for para in next_cell.paragraphs:
+                        if para.runs:
+                            para.runs[0].text = value
+                        else:
+                            para.text = value
+                    updated += 1
+
+doc.save("/sandbox/output/document.docx")
+print(f"SUCCESS: Filled {updated} fields")
+`;
+}
+/* ------------------------------------------------------------------ */
+/* PPTX — Extract text from slides                                     */
+/* ------------------------------------------------------------------ */
+export function generateExtractPPTXScript() {
+    return `
+import json
+from pptx import Presentation
+from pptx.util import Inches, Pt
+
+prs = Presentation("/sandbox/input/document.pptx")
+slides = []
+
+for i, slide in enumerate(prs.slides):
+    texts = []
+    fields = []
+    
+    for shape in slide.shapes:
+        if shape.has_text_frame:
+            for para in shape.text_frame.paragraphs:
+                text = para.text.strip()
+                if text:
+                    texts.append(text)
+                    
+                    # Detect form-like patterns
+                    if ":" in text and text.endswith(":"):
+                        fields.append({
+                            "name": text.rstrip(":").strip(),
+                            "type": "text",
+                            "value": "",
+                            "slideIndex": i,
+                        })
+                    elif "___" in text:
+                        label = text.split("___")[0].strip().rstrip(":")
+                        if label:
+                            fields.append({
+                                "name": label,
+                                "type": "text",
+                                "value": "",
+                                "slideIndex": i,
+                            })
+    
+    slides.append({
+        "index": i,
+        "text": "\\n".join(texts),
+        "fields": fields,
+    })
+
+result = {
+    "slides": slides,
+    "totalSlides": len(prs.slides),
+}
+
+print("__RESULT__:" + json.dumps(result, default=str))
+`;
+}
+/* ------------------------------------------------------------------ */
+/* PPTX — Edit slide text                                              */
+/* ------------------------------------------------------------------ */
+export function generateEditPPTXScript(edits) {
+    const editsJson = JSON.stringify(edits);
+    return `
+import json
+from pptx import Presentation
+
+prs = Presentation("/sandbox/input/document.pptx")
+edits = json.loads('''${editsJson}''')
+
+updated = 0
+for edit in edits:
+    slide_index = edit.get("pageIndex", 0)
+    if slide_index >= len(prs.slides):
+        continue
+    
+    slide = prs.slides[slide_index]
+    edit_type = edit.get("type", "replace_text")
+    
+    if edit_type == "replace_text":
+        search = edit.get("search", "")
+        replacement = edit.get("text", "")
+        
+        for shape in slide.shapes:
+            if shape.has_text_frame:
+                for para in shape.text_frame.paragraphs:
+                    for run in para.runs:
+                        if search in run.text:
+                            run.text = run.text.replace(search, replacement)
+                            updated += 1
+
+prs.save("/sandbox/output/document.pptx")
+print(f"SUCCESS: Applied {updated} edits")
+`;
+}
+/* ------------------------------------------------------------------ */
+/* PPTX — Fill form fields in slides                                   */
+/* ------------------------------------------------------------------ */
+export function generateFillPPTXScript(edits) {
+    const editsJson = JSON.stringify(edits);
+    return `
+import json
+from pptx import Presentation
+
+prs = Presentation("/sandbox/input/document.pptx")
+edits = json.loads('''${editsJson}''')
+
+field_map = {edit["fieldId"]: edit["value"] for edit in edits}
+updated = 0
+
+for slide in prs.slides:
+    for shape in slide.shapes:
+        if shape.has_text_frame:
+            for para in shape.text_frame.paragraphs:
+                full_text = para.text
+                for field_id, value in field_map.items():
+                    # Replace "___" blanks after field labels
+                    if "___" in full_text:
+                        for run in para.runs:
+                            if "___" in run.text:
+                                run.text = run.text.replace("___", value, 1)
+                                updated += 1
+
+prs.save("/sandbox/output/document.pptx")
+print(f"SUCCESS: Filled {updated} fields")
+`;
+}

package/dist/types.d.ts

@@ -0,0 +1,158 @@
+/** Supported document types */
+export type DocumentType = 'pdf' | 'docx' | 'pptx' | 'txt' | 'xlsx';
+/** A single editable field detected in a document */
+export interface DocumentField {
+    /** Unique field identifier within the document */
+    id: string;
+    /** Human-readable field name / label */
+    name: string;
+    /** Field type */
+    type: 'text' | 'textarea' | 'checkbox' | 'radio' | 'date' | 'number' | 'select' | 'signature_placeholder';
+    /** Current value (empty if unfilled) */
+    value: string;
+    /** Page/slide index (0-based) */
+    pageIndex: number;
+    /** Whether the field is required (if detectable) */
+    required?: boolean;
+    /** Placeholder or tooltip text */
+    placeholder?: string;
+    /** Options for select/radio fields */
+    options?: string[];
+    /** Bounding box for overlay positioning (PDF) — percentages of page */
+    bbox?: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    /** Context around the field (for smart detection) */
+    context?: string;
+}
+/** A single page or slide of a parsed document */
+export interface DocumentPage {
+    /** 0-based page/slide index */
+    index: number;
+    /** Extracted text content */
+    text: string;
+    /** HTML rendering (for DOCX via mammoth) */
+    html?: string;
+    /** Fields on this page */
+    fields: DocumentField[];
+    /** Page dimensions in points (PDF) */
+    dimensions?: {
+        width: number;
+        height: number;
+    };
+}
+/** Result of parsing a document */
+export interface ParsedDocument {
+    /** Session ID for tracking edits */
+    sessionId: string;
+    /** Original filename */
+    fileName: string;
+    /** Detected document type */
+    type: DocumentType;
+    /** MIME type */
+    mimeType: string;
+    /** File size in bytes */
+    fileSize: number;
+    /** Pages/slides */
+    pages: DocumentPage[];
+    /** All fields across all pages (flat) */
+    fields: DocumentField[];
+    /** Full raw text extraction */
+    rawText: string;
+    /** Document metadata (author, title, dates, etc.) */
+    metadata: Record<string, string>;
+    /** Total page/slide count */
+    totalPages: number;
+}
+/** An edit operation to apply to a document */
+export interface FieldEdit {
+    /** Field ID to update */
+    fieldId: string;
+    /** New value */
+    value: string;
+    /** Type of edit */
+    type: 'fill' | 'replace' | 'append' | 'clear';
+}
+/** A content-level edit (not field-based) */
+export interface ContentEdit {
+    /** Page/slide index */
+    pageIndex: number;
+    /** Type of content edit */
+    type: 'replace_text' | 'insert_text' | 'delete_text';
+    /** Search text (for replace) */
+    search?: string;
+    /** Replacement or insertion text */
+    text: string;
+    /** Position for insert (paragraph index) */
+    position?: number;
+}
+/** Signature details for applying to a document */
+export interface SignatureData {
+    /** The mode of the signature */
+    mode: 'type' | 'draw' | 'upload';
+    /** Base64 image of the signature (for draw/upload) */
+    imagePayload?: string;
+    /** Typed text for the signature */
+    text?: string;
+    /** Font family for typed text */
+    font?: string;
+    /** Color (hex) */
+    color?: string;
+    /** Optional date to include */
+    date?: string;
+    /** Optional extra text */
+    extraText?: string;
+    /** Page index (0-based) where the signature should be placed */
+    pageIndex: number;
+    /** Approximate X coordinate (if known) */
+    x?: number;
+    /** Approximate Y coordinate (if known) */
+    y?: number;
+    /** Signature scale multiplier */
+    scale?: number;
+    /** Optional base64 to use instead of current session base64 (for undo/replace) */
+    base64Override?: string;
+    /** The text context detected near the signature line (e.g. "Datum, Unterschrift des Empfängers") */
+    detectedContext?: string;
+    /** User-provided note about placement (e.g. "bottom right corner") */
+    placementNote?: string;
+}
+/** Active editing session */
+export interface EditorSession {
+    /** Unique session ID */
+    id: string;
+    /** Original filename */
+    fileName: string;
+    /** Document type */
+    type: DocumentType;
+    /** MIME type */
+    mimeType: string;
+    /** Original file as base64 */
+    originalFileBase64: string;
+    /** Current (modified) file as base64 */
+    currentFileBase64: string;
+    /** Parsed document state */
+    parsed: ParsedDocument;
+    /** Applied edits history */
+    edits: FieldEdit[];
+    /** Created timestamp */
+    createdAt: string;
+    /** Last modified timestamp */
+    updatedAt: string;
+}
+/** Result of applying edits */
+export interface EditResult {
+    /** Whether the edit succeeded */
+    success: boolean;
+    /** Updated parsed document */
+    parsed: ParsedDocument;
+    /** Updated file as base64 */
+    fileBase64: string;
+    /** Error message if failed */
+    error?: string;
+    /** Fields that were updated */
+    updatedFields: string[];
+}

package/dist/types.js

@@ -0,0 +1,4 @@
+/* ------------------------------------------------------------------ */
+/* Types for the Document Editor / Form Filling tool                   */
+/* ------------------------------------------------------------------ */
+export {};

package/package.json

@@ -0,0 +1,68 @@
+{
+  "name": "@larkup/tool-doc-editor",
+  "version": "0.2.0",
+  "publishConfig": {
+    "access": "public"
+  },
+  "type": "module",
+  "description": "Larkup marketplace tool: AI-powered form filling and document editing.",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types.d.ts",
+      "import": "./dist/types.js",
+      "default": "./dist/types.js"
+    },
+    "./parsers": {
+      "types": "./dist/parsers.d.ts",
+      "import": "./dist/parsers.js",
+      "default": "./dist/parsers.js"
+    },
+    "./editor": {
+      "types": "./dist/editor.d.ts",
+      "import": "./dist/editor.js",
+      "default": "./dist/editor.js"
+    }
+  },
+  "files": [
+    "dist",
+    "src",
+    "tool.manifest.json",
+    "README.md"
+  ],
+  "dependencies": {
+    "jszip": "^3.10.1",
+    "mammoth": "^1.12.0",
+    "pdf-lib": "^1.17.1",
+    "@larkup/sandbox": "0.1.1",
+    "@larkup/core": "0.2.0"
+  },
+  "peerDependencies": {
+    "@larkup/marketplace": ">=0.1.0"
+  },
+  "peerDependenciesMeta": {
+    "@larkup/marketplace": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "typescript": "5.7.3",
+    "@larkup/marketplace": "0.1.1"
+  },
+  "license": "Apache-2.0",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Larkup-AI/larkup-rag",
+    "directory": "packages/tools/doc-editor"
+  },
+  "scripts": {
+    "build": "tsc --outDir dist",
+    "type-check": "tsc --noEmit"
+  }
+}