autoform-mcp-server 1.2.0

package/dist/tools/fillAtCoordinates.d.ts

@@ -0,0 +1,94 @@
+export declare const fillAtCoordinatesSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            pdf_path: {
+                type: string;
+                description: string;
+            };
+            fields: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        text: {
+                            type: string;
+                            description: string;
+                        };
+                        page: {
+                            type: string;
+                            description: string;
+                        };
+                        x: {
+                            type: string;
+                            description: string;
+                        };
+                        y: {
+                            type: string;
+                            description: string;
+                        };
+                        width: {
+                            type: string;
+                            description: string;
+                        };
+                        height: {
+                            type: string;
+                            description: string;
+                        };
+                        fontSize: {
+                            type: string;
+                            description: string;
+                        };
+                        overflowMode: {
+                            type: string;
+                            enum: string[];
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            output_path: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare const getPdfInfoSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            pdf_path: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleFillAtCoordinates(args: any): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+}>;
+export declare function handleGetPdfInfo(args: any): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/fillAtCoordinates.js

@@ -0,0 +1,113 @@
+import * as path from 'path';
+import { PdfService } from '../services/pdfService.js';
+const OUTPUT_DIR = path.resolve(import.meta.dirname, '../../output');
+export const fillAtCoordinatesSchema = {
+    name: 'autoform_fill_at_coordinates',
+    description: `Escribe texto en posiciones exactas de un PDF usando coordenadas en puntos PDF (origen: esquina inferior-izquierda).
+Ideal cuando Claude analiza visualmente un PDF y determina dónde colocar el texto.
+
+FLUJO RECOMENDADO:
+1. Primero usa autoform_get_pdf_info para obtener las dimensiones de cada página
+2. Basándote en el análisis visual del PDF, calcula las coordenadas en puntos PDF
+3. Recuerda: Y=0 está ABAJO, Y aumenta hacia ARRIBA
+
+SISTEMA DE COORDENADAS:
+- Origen (0,0) = esquina inferior-izquierda de la página
+- X aumenta hacia la derecha
+- Y aumenta hacia arriba
+- Una página A4 típica mide ~595 x 842 puntos
+- Una página Letter típica mide ~612 x 792 puntos`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            pdf_path: {
+                type: 'string',
+                description: 'Ruta absoluta al archivo PDF'
+            },
+            fields: {
+                type: 'array',
+                description: 'Array de campos a llenar con coordenadas exactas',
+                items: {
+                    type: 'object',
+                    properties: {
+                        text: { type: 'string', description: 'Texto a escribir' },
+                        page: { type: 'number', description: 'Número de página (1-indexed)' },
+                        x: { type: 'number', description: 'Posición X en puntos desde la izquierda' },
+                        y: { type: 'number', description: 'Posición Y en puntos desde abajo' },
+                        width: { type: 'number', description: 'Ancho del campo en puntos' },
+                        height: { type: 'number', description: 'Alto del campo en puntos' },
+                        fontSize: { type: 'number', description: '(Opcional) Tamaño de fuente. Default: 12' },
+                        overflowMode: { type: 'string', enum: ['shrink', 'wrap'], description: '(Opcional) shrink=reducir tamaño, wrap=salto de línea. Default: shrink' }
+                    },
+                    required: ['text', 'page', 'x', 'y', 'width', 'height']
+                }
+            },
+            output_path: {
+                type: 'string',
+                description: '(Opcional) Ruta donde guardar el PDF. Si no se especifica, se guarda en output/'
+            }
+        },
+        required: ['pdf_path', 'fields']
+    }
+};
+export const getPdfInfoSchema = {
+    name: 'autoform_get_pdf_info',
+    description: 'Obtiene información del PDF: número de páginas y dimensiones de cada página en puntos. Útil para calcular coordenadas antes de usar autoform_fill_at_coordinates.',
+    inputSchema: {
+        type: 'object',
+        properties: {
+            pdf_path: {
+                type: 'string',
+                description: 'Ruta absoluta al archivo PDF'
+            }
+        },
+        required: ['pdf_path']
+    }
+};
+export async function handleFillAtCoordinates(args) {
+    const { pdf_path, output_path } = args;
+    // fields puede llegar como string JSON o como array — normalizar
+    let fields = args.fields;
+    if (typeof fields === 'string') {
+        try {
+            fields = JSON.parse(fields);
+        }
+        catch { /* keep as-is */ }
+    }
+    if (!fields || !Array.isArray(fields) || fields.length === 0) {
+        return {
+            content: [{ type: 'text', text: JSON.stringify({ error: true, message: 'No se proporcionaron campos válidos.' }, null, 2) }],
+            isError: true
+        };
+    }
+    const outputFile = output_path || path.join(OUTPUT_DIR, `coords_${path.basename(pdf_path, '.pdf')}_${Date.now()}.pdf`);
+    const filled = await PdfService.fillAtCoordinates(pdf_path, fields, outputFile);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    fields_filled: filled,
+                    output_path: outputFile,
+                    message: `${filled} campo(s) escritos en el PDF. Archivo: ${outputFile}`
+                }, null, 2)
+            }]
+    };
+}
+export async function handleGetPdfInfo(args) {
+    const { pdf_path } = args;
+    const pages = await PdfService.getPageDimensions(pdf_path);
+    const { fields, hasAcroform } = await PdfService.detectFields(pdf_path);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    total_pages: pages.length,
+                    pages,
+                    has_acroform: hasAcroform,
+                    acroform_fields: fields.length,
+                    coordinate_system: 'Origen (0,0) = esquina inferior-izquierda. X→derecha, Y→arriba. Unidades: puntos PDF (1 punto = 1/72 pulgada).',
+                    message: `PDF con ${pages.length} página(s). ${pages.map(p => `Pág ${p.page}: ${p.width} x ${p.height} pts`).join(', ')}`
+                }, null, 2)
+            }]
+    };
+}

package/dist/tools/fillBatchAtCoordinates.d.ts

@@ -0,0 +1,88 @@
+export declare const fillBatchAtCoordinatesSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            pdf_path: {
+                type: string;
+                description: string;
+            };
+            field_definitions: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    properties: {
+                        label: {
+                            type: string;
+                            description: string;
+                        };
+                        page: {
+                            type: string;
+                            description: string;
+                        };
+                        x: {
+                            type: string;
+                            description: string;
+                        };
+                        y: {
+                            type: string;
+                            description: string;
+                        };
+                        width: {
+                            type: string;
+                            description: string;
+                        };
+                        height: {
+                            type: string;
+                            description: string;
+                        };
+                        fontSize: {
+                            type: string;
+                            description: string;
+                        };
+                        overflowMode: {
+                            type: string;
+                            enum: string[];
+                            description: string;
+                        };
+                    };
+                    required: string[];
+                };
+            };
+            data_rows: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    additionalProperties: {
+                        type: string;
+                    };
+                };
+            };
+            merge_into_single: {
+                type: string;
+                description: string;
+            };
+            output_dir: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleFillBatchAtCoordinates(args: any): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+}>;

package/dist/tools/fillBatchAtCoordinates.js

@@ -0,0 +1,102 @@
+import * as path from 'path';
+import { PdfService } from '../services/pdfService.js';
+const OUTPUT_DIR = path.resolve(import.meta.dirname, '../../output');
+export const fillBatchAtCoordinatesSchema = {
+    name: 'autoform_fill_batch_at_coordinates',
+    description: `Genera MULTIPLES PDFs a partir de un mismo PDF base, escribiendo datos diferentes en las mismas posiciones de cada copia.
+
+CUANDO USAR: El usuario pasa un PDF (certificado, diploma, constancia) y una LISTA de datos (nombres, fechas, etc.) y quiere generar un PDF por cada fila de datos.
+
+FLUJO:
+1. Usa autoform_get_pdf_info para obtener las dimensiones de la pagina
+2. Analiza visualmente el PDF para determinar donde van los campos
+3. Define los campos con label (nombre logico) + coordenadas
+4. Pasa las filas de datos como array de objetos {label: valor}
+5. Opcionalmente unifica todo en un solo PDF con merge_into_single
+
+SISTEMA DE COORDENADAS: Origen (0,0) = esquina inferior-izquierda. Y aumenta hacia arriba. Unidades: puntos PDF.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            pdf_path: {
+                type: 'string',
+                description: 'Ruta absoluta al PDF base (la plantilla)'
+            },
+            field_definitions: {
+                type: 'array',
+                description: 'Definicion de los campos: donde va cada dato en el PDF. El "label" es la clave que conecta con los datos.',
+                items: {
+                    type: 'object',
+                    properties: {
+                        label: { type: 'string', description: 'Nombre logico del campo (ej: "nombre", "fecha"). Debe coincidir con las claves de data_rows.' },
+                        page: { type: 'number', description: 'Pagina (1-indexed)' },
+                        x: { type: 'number', description: 'X en puntos desde la izquierda' },
+                        y: { type: 'number', description: 'Y en puntos desde abajo' },
+                        width: { type: 'number', description: 'Ancho en puntos' },
+                        height: { type: 'number', description: 'Alto en puntos' },
+                        fontSize: { type: 'number', description: '(Opcional) Tamaño de fuente. Default: 12' },
+                        overflowMode: { type: 'string', enum: ['shrink', 'wrap'], description: '(Opcional) Default: shrink' }
+                    },
+                    required: ['label', 'page', 'x', 'y', 'width', 'height']
+                }
+            },
+            data_rows: {
+                type: 'array',
+                description: 'Array de objetos con los datos. Cada objeto es un documento. Las claves deben coincidir con los "label" de field_definitions.',
+                items: {
+                    type: 'object',
+                    additionalProperties: { type: 'string' }
+                }
+            },
+            merge_into_single: {
+                type: 'boolean',
+                description: '(Opcional) Si true, une todos los PDFs en uno solo. Default: false'
+            },
+            output_dir: {
+                type: 'string',
+                description: '(Opcional) Directorio de salida. Default: output/'
+            }
+        },
+        required: ['pdf_path', 'field_definitions', 'data_rows']
+    }
+};
+export async function handleFillBatchAtCoordinates(args) {
+    const { pdf_path, output_dir, merge_into_single = false } = args;
+    let field_definitions = args.field_definitions;
+    if (typeof field_definitions === 'string') {
+        try {
+            field_definitions = JSON.parse(field_definitions);
+        }
+        catch { /* keep */ }
+    }
+    let data_rows = args.data_rows;
+    if (typeof data_rows === 'string') {
+        try {
+            data_rows = JSON.parse(data_rows);
+        }
+        catch { /* keep */ }
+    }
+    if (!field_definitions || !Array.isArray(field_definitions) || field_definitions.length === 0) {
+        return { content: [{ type: 'text', text: JSON.stringify({ error: true, message: 'field_definitions es requerido (array de campos con coordenadas)' }, null, 2) }], isError: true };
+    }
+    if (!data_rows || !Array.isArray(data_rows) || data_rows.length === 0) {
+        return { content: [{ type: 'text', text: JSON.stringify({ error: true, message: 'data_rows es requerido (array de objetos con datos)' }, null, 2) }], isError: true };
+    }
+    const outDir = output_dir || OUTPUT_DIR;
+    const baseName = path.basename(pdf_path, '.pdf').replace(/[^a-zA-Z0-9_\-]/g, '_');
+    const result = await PdfService.batchFillAtCoordinates(pdf_path, field_definitions, data_rows, outDir, baseName, merge_into_single);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    documents_generated: result.outputPaths.length,
+                    output_paths: result.outputPaths,
+                    merged_path: result.mergedPath,
+                    errors: result.errors,
+                    message: result.outputPaths.length > 0
+                        ? `Generados ${result.outputPaths.length} documentos.${result.mergedPath ? ` PDF unificado: ${result.mergedPath}` : ''}`
+                        : `Error: no se generaron documentos. ${result.errors.join(', ')}`
+                }, null, 2)
+            }]
+    };
+}

package/dist/tools/fillPdf.d.ts

@@ -0,0 +1,42 @@
+export declare const fillPdfSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            pdf_path: {
+                type: string;
+                description: string;
+            };
+            field_values: {
+                type: string;
+                description: string;
+                additionalProperties: {
+                    type: string;
+                };
+            };
+            output_path: {
+                type: string;
+                description: string;
+            };
+            template_name: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleFillPdf(args: any): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+}>;

package/dist/tools/fillPdf.js

@@ -0,0 +1,97 @@
+import * as path from 'path';
+import { PdfService } from '../services/pdfService.js';
+import { TemplateStore } from '../services/templateStore.js';
+const OUTPUT_DIR = path.resolve(import.meta.dirname, '../../output');
+export const fillPdfSchema = {
+    name: 'autoform_fill_pdf',
+    description: `Llena UN PDF con valores. Detecta automaticamente si tiene AcroForm o usa un template guardado.
+
+CUANDO USAR: Quieres llenar UN SOLO documento y ya tienes AcroForm o un template guardado.
+NO USAR SI: El PDF es estatico sin template → usa autoform_fill_at_coordinates.
+NO USAR SI: Quieres generar MULTIPLES documentos → usa autoform_generate_batch o autoform_fill_batch_at_coordinates.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            pdf_path: {
+                type: 'string',
+                description: 'Ruta absoluta al archivo PDF a llenar'
+            },
+            field_values: {
+                type: 'object',
+                description: 'Objeto con los valores a llenar. Claves = nombre del campo, valores = texto a insertar. Ejemplo: { "nombre": "Juan", "dni": "12345" }',
+                additionalProperties: { type: 'string' }
+            },
+            output_path: {
+                type: 'string',
+                description: '(Opcional) Ruta donde guardar el PDF llenado. Si no se especifica, se guarda en la carpeta output/'
+            },
+            template_name: {
+                type: 'string',
+                description: '(Opcional) Nombre del template a usar para posicionar los campos. Solo necesario si el PDF no tiene AcroForm.'
+            }
+        },
+        required: ['pdf_path', 'field_values']
+    }
+};
+export async function handleFillPdf(args) {
+    const { pdf_path, output_path, template_name } = args;
+    let field_values = args.field_values;
+    if (typeof field_values === 'string') {
+        try {
+            field_values = JSON.parse(field_values);
+        }
+        catch { /* keep as-is */ }
+    }
+    const outputFile = output_path || path.join(OUTPUT_DIR, `filled_${path.basename(pdf_path, '.pdf')}_${Date.now()}.pdf`);
+    // Try AcroForm first
+    const { fields, hasAcroform } = await PdfService.detectFields(pdf_path);
+    if (hasAcroform && fields.length > 0) {
+        const filled = await PdfService.fillAcroForm(pdf_path, field_values, outputFile);
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        method: 'acroform',
+                        fields_filled: filled,
+                        output_path: outputFile,
+                        message: `PDF llenado exitosamente usando AcroForm. ${filled} campo(s) completados.`
+                    }, null, 2)
+                }]
+        };
+    }
+    // No AcroForm — try template
+    let template = template_name ? TemplateStore.load(template_name) : null;
+    // If no template specified, try to find one matching the PDF name
+    if (!template) {
+        const allTemplates = TemplateStore.list();
+        const pdfBaseName = path.basename(pdf_path).toLowerCase();
+        const match = allTemplates.find(t => t.name.toLowerCase().includes(pdfBaseName.replace('.pdf', '')));
+        if (match)
+            template = TemplateStore.load(match.name);
+    }
+    if (!template) {
+        return {
+            content: [{
+                    type: 'text',
+                    text: JSON.stringify({
+                        error: true,
+                        message: `El PDF no tiene campos AcroForm y no se encontro un template con las coordenadas de los campos.\n\nOpciones:\n1. Abra el PDF en la app web de AutoForm, defina los campos visualmente, y exporte como template JSON\n2. Importe el template con autoform_import_template\n3. Luego use autoform_fill_pdf con template_name="nombre_del_template"`
+                    }, null, 2)
+                }],
+            isError: true
+        };
+    }
+    const filled = await PdfService.fillWithTemplate(pdf_path, template.fields, field_values, outputFile);
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    method: 'template',
+                    template_used: template.name,
+                    fields_filled: filled,
+                    output_path: outputFile,
+                    message: `PDF llenado usando template "${template.name}". ${filled} campo(s) completados.`
+                }, null, 2)
+            }]
+    };
+}

package/dist/tools/generateBatch.d.ts

@@ -0,0 +1,46 @@
+export declare const generateBatchSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            template_name: {
+                type: string;
+                description: string;
+            };
+            data: {
+                type: string;
+                description: string;
+                items: {
+                    type: string;
+                    additionalProperties: {
+                        type: string;
+                    };
+                };
+            };
+            distribution_mode: {
+                type: string;
+                enum: string[];
+                description: string;
+            };
+            merge_into_single: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleGenerateBatch(args: any): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError: boolean;
+} | {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    isError?: undefined;
+}>;