@larkup/tool-doc-editor 0.2.0

package/src/sandbox-scripts.ts

@@ -0,0 +1,380 @@
+/**
+ * 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/
+ */
+
+import type { FieldEdit, ContentEdit } from './types.js';
+
+/* ------------------------------------------------------------------ */
+/* PDF — Fill form fields using pypdf                                  */
+/* ------------------------------------------------------------------ */
+
+export function generateFillPDFScript(edits: FieldEdit[]): string {
+  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(): string {
+  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: ContentEdit[]): string {
+  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: FieldEdit[]): string {
+  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(): string {
+  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: ContentEdit[]): string {
+  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: FieldEdit[]): string {
+  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/src/types.ts

@@ -0,0 +1,170 @@
+/* ------------------------------------------------------------------ */
+/* Types for the Document Editor / Form Filling tool                   */
+/* ------------------------------------------------------------------ */
+
+/** 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/tool.manifest.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://hub.larkup.de/schemas/tool-manifest.v1.json",
+  "id": "doc-editor",
+  "name": "Document Editor",
+  "description": "AI-powered form filling and document editing with Canvas-style live preview.",
+  "longDescription": "Open PDF, Word, PowerPoint, and text files in a split-view Canvas. AI fills forms using your knowledge base, edits content on request, and previews changes live. Supports PDF form fields (AcroForm), DOCX paragraphs/tables, PPTX slide text, and plain text editing. Uses pdf-lib (native) for PDF and the Docker sandbox for DOCX/PPTX via python-docx/python-pptx.",
+  "category": "utility",
+  "version": "0.1.0",
+  "pricing": "free",
+  "emoji": "📝",
+  "icon": "FileEdit",
+  "packageName": "@larkup/tool-doc-editor",
+  "installSize": "~5 MB",
+  "systemDeps": ["docker"],
+  "author": "Larkup",
+  "capabilities": ["document-editing", "form-filling", "document-preview"],
+  "tags": ["pdf", "docx", "pptx", "form", "canvas", "editor", "fill"],
+  "downloads": 0,
+  "repositoryUrl": "https://github.com/Larkup-AI/larkup-rag",
+  "license": "Apache-2.0",
+  "updatedAt": "2026-07-20"
+}