autoform-mcp-server 1.2.0

package/dist/services/pdfService.js

@@ -0,0 +1,412 @@
+import { PDFDocument, PDFTextField, PDFCheckBox, PDFDropdown, PDFRadioGroup, StandardFonts, rgb } from 'pdf-lib';
+import * as fs from 'fs';
+import * as path from 'path';
+/**
+ * PDF field detection and filling service.
+ * Uses pdf-lib's AcroForm API for detection + drawText for template-based filling.
+ */
+export class PdfService {
+    /** Detect AcroForm fields in a PDF */
+    static async detectFields(pdfPath) {
+        const bytes = fs.readFileSync(pdfPath);
+        const pdfDoc = await PDFDocument.load(bytes, { ignoreEncryption: true });
+        const fields = [];
+        let hasAcroform = false;
+        try {
+            const form = pdfDoc.getForm();
+            const formFields = form.getFields();
+            if (formFields.length > 0) {
+                hasAcroform = true;
+                for (const field of formFields) {
+                    const name = field.getName();
+                    const type = field.constructor.name.replace('PDF', '').replace('Field', '').toLowerCase();
+                    const widgets = field.acroField.getWidgets();
+                    for (let wi = 0; wi < widgets.length; wi++) {
+                        const widget = widgets[wi];
+                        const rect = widget.getRectangle();
+                        // Determine page number
+                        const pageRef = widget.P();
+                        let pageNum = 1;
+                        if (pageRef) {
+                            const pages = pdfDoc.getPages();
+                            for (let pi = 0; pi < pages.length; pi++) {
+                                if (pages[pi].ref === pageRef) {
+                                    pageNum = pi + 1;
+                                    break;
+                                }
+                            }
+                        }
+                        let value;
+                        if (field instanceof PDFTextField) {
+                            value = field.getText() ?? undefined;
+                        }
+                        fields.push({
+                            name: widgets.length > 1 ? `${name}[${wi}]` : name,
+                            type,
+                            page: pageNum,
+                            x: rect.x,
+                            y: rect.y,
+                            width: rect.width,
+                            height: rect.height,
+                            value
+                        });
+                    }
+                }
+            }
+        }
+        catch {
+            // No form in this PDF
+        }
+        return { fields, hasAcroform };
+    }
+    /** Fill AcroForm fields and save */
+    static async fillAcroForm(pdfPath, values, outputPath) {
+        const bytes = fs.readFileSync(pdfPath);
+        const pdfDoc = await PDFDocument.load(bytes);
+        const form = pdfDoc.getForm();
+        let filled = 0;
+        for (const [name, value] of Object.entries(values)) {
+            try {
+                const field = form.getField(name);
+                if (field instanceof PDFTextField) {
+                    field.setText(value);
+                    filled++;
+                }
+                else if (field instanceof PDFCheckBox) {
+                    if (['true', '1', 'yes', 'si', 'sí'].includes(value.toLowerCase()))
+                        field.check();
+                    else
+                        field.uncheck();
+                    filled++;
+                }
+                else if (field instanceof PDFDropdown) {
+                    field.select(value);
+                    filled++;
+                }
+                else if (field instanceof PDFRadioGroup) {
+                    field.select(value);
+                    filled++;
+                }
+            }
+            catch {
+                // Field not found or wrong type — skip
+            }
+        }
+        form.flatten();
+        const savedBytes = await pdfDoc.save();
+        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+        fs.writeFileSync(outputPath, savedBytes);
+        return filled;
+    }
+    /** Fill PDF using template coordinates (drawText), same logic as web app's pdfGenerator */
+    static async fillWithTemplate(pdfPath, fields, values, outputPath) {
+        const bytes = fs.readFileSync(pdfPath);
+        const basePdf = await PDFDocument.load(bytes);
+        const pdfDoc = await PDFDocument.create();
+        const pages = await pdfDoc.copyPages(basePdf, basePdf.getPageIndices());
+        pages.forEach(p => pdfDoc.addPage(p));
+        const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
+        let filled = 0;
+        for (const field of fields) {
+            const value = values[field.fieldName];
+            if (!value || value.trim() === '')
+                continue;
+            const pageIndex = field.pageNumber - 1;
+            if (pageIndex < 0 || pageIndex >= pdfDoc.getPageCount())
+                continue;
+            const page = pdfDoc.getPage(pageIndex);
+            this.drawFieldText(page, field, value, font);
+            filled++;
+        }
+        const savedBytes = await pdfDoc.save({ useObjectStreams: true });
+        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+        fs.writeFileSync(outputPath, savedBytes);
+        return filled;
+    }
+    /**
+     * Fill PDF at exact coordinates (points, PDF native system — origin bottom-left).
+     * Designed for Claude to pass positions it determined visually.
+     */
+    static async fillAtCoordinates(pdfPath, fields, outputPath) {
+        const bytes = fs.readFileSync(pdfPath);
+        const basePdf = await PDFDocument.load(bytes, { ignoreEncryption: true });
+        const pdfDoc = await PDFDocument.create();
+        const pages = await pdfDoc.copyPages(basePdf, basePdf.getPageIndices());
+        pages.forEach(p => pdfDoc.addPage(p));
+        const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
+        let filled = 0;
+        for (const field of fields) {
+            const sanitized = this.sanitize(field.text);
+            if (!sanitized)
+                continue;
+            const pageIndex = field.page - 1;
+            if (pageIndex < 0 || pageIndex >= pdfDoc.getPageCount())
+                continue;
+            const page = pdfDoc.getPage(pageIndex);
+            const pad = 2;
+            const maxW = field.width - pad * 2;
+            const maxH = field.height - pad * 2;
+            const desiredMax = field.fontSize ?? 12;
+            const minSize = 6;
+            const mode = field.overflowMode ?? 'shrink';
+            if (mode === 'wrap') {
+                let fs = desiredMax;
+                let lines = this.wrapText(sanitized, maxW, font, fs);
+                let totalH = lines.length * font.heightAtSize(fs) * 1.15;
+                while (totalH > maxH && fs > minSize) {
+                    fs -= 0.5;
+                    lines = this.wrapText(sanitized, maxW, font, fs);
+                    totalH = lines.length * font.heightAtSize(fs) * 1.15;
+                }
+                if (lines.length === 0)
+                    continue;
+                const lineH = font.heightAtSize(fs) * 1.15;
+                const startY = field.y + field.height - pad - font.heightAtSize(fs);
+                const vOff = Math.max(0, (maxH - lines.length * lineH) / 2);
+                for (let i = 0; i < lines.length; i++) {
+                    const ly = startY - i * lineH - vOff;
+                    if (ly < field.y)
+                        break;
+                    page.drawText(lines[i], { x: field.x + pad, y: ly, size: fs, font, color: rgb(0, 0, 0) });
+                }
+            }
+            else {
+                const fs = this.optimalFontSize(sanitized, maxW, maxH, font, minSize, desiredMax);
+                const fitsOneLine = font.widthOfTextAtSize(sanitized, fs) <= maxW;
+                if (fitsOneLine) {
+                    const th = font.heightAtSize(fs);
+                    page.drawText(sanitized, { x: field.x + pad, y: field.y + (field.height - th) / 2, size: fs, font, color: rgb(0, 0, 0) });
+                }
+                else {
+                    const lines = this.wrapText(sanitized, maxW, font, fs);
+                    const lineH = font.heightAtSize(fs) * 1.15;
+                    const startY = field.y + field.height - pad - font.heightAtSize(fs);
+                    const vOff = Math.max(0, (maxH - lines.length * lineH) / 2);
+                    for (let i = 0; i < lines.length; i++) {
+                        const ly = startY - i * lineH - vOff;
+                        if (ly < field.y)
+                            break;
+                        page.drawText(lines[i], { x: field.x + pad, y: ly, size: fs, font, color: rgb(0, 0, 0) });
+                    }
+                }
+            }
+            filled++;
+        }
+        const savedBytes = await pdfDoc.save({ useObjectStreams: true });
+        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+        fs.writeFileSync(outputPath, savedBytes);
+        return filled;
+    }
+    /**
+     * Batch fill: generates multiple PDFs from the same template with different data sets.
+     * Each entry in `dataRows` produces one PDF using the same field positions.
+     */
+    static async batchFillAtCoordinates(pdfPath, fieldDefinitions, dataRows, outputDir, baseName, merge = false) {
+        const bytes = fs.readFileSync(pdfPath);
+        const outputPaths = [];
+        const errors = [];
+        const timestamp = new Date().toISOString().slice(0, 10);
+        fs.mkdirSync(outputDir, { recursive: true });
+        for (let i = 0; i < dataRows.length; i++) {
+            try {
+                const row = dataRows[i];
+                const fields = fieldDefinitions.map(def => ({
+                    text: row[def.label] || '',
+                    page: def.page,
+                    x: def.x,
+                    y: def.y,
+                    width: def.width,
+                    height: def.height,
+                    fontSize: def.fontSize,
+                    overflowMode: def.overflowMode
+                })).filter(f => f.text.trim() !== '');
+                const num = String(i + 1).padStart(3, '0');
+                const outPath = path.join(outputDir, `${baseName}_${num}_${timestamp}.pdf`);
+                await this.fillAtCoordinates(pdfPath, fields, outPath);
+                outputPaths.push(outPath);
+            }
+            catch (err) {
+                errors.push(`Fila ${i + 1}: ${err instanceof Error ? err.message : String(err)}`);
+            }
+        }
+        let mergedPath;
+        if (merge && outputPaths.length > 0) {
+            mergedPath = path.join(outputDir, `${baseName}_merged_${timestamp}.pdf`);
+            await this.mergePdfs(outputPaths, mergedPath);
+        }
+        return { outputPaths, mergedPath, errors };
+    }
+    /** Get PDF page dimensions (useful for Claude to calculate coordinates) */
+    static async getPageDimensions(pdfPath) {
+        const bytes = fs.readFileSync(pdfPath);
+        const pdfDoc = await PDFDocument.load(bytes, { ignoreEncryption: true });
+        return pdfDoc.getPages().map((p, i) => {
+            const { width, height } = p.getSize();
+            return { page: i + 1, width: Math.round(width * 100) / 100, height: Math.round(height * 100) / 100 };
+        });
+    }
+    /** Generate a single document with field mappings (for batch generation) */
+    static async generateSingleDocument(basePdfBytes, mappings, outputPath) {
+        const basePdf = await PDFDocument.load(basePdfBytes);
+        const pdfDoc = await PDFDocument.create();
+        const pages = await pdfDoc.copyPages(basePdf, basePdf.getPageIndices());
+        pages.forEach(p => pdfDoc.addPage(p));
+        const font = await pdfDoc.embedFont(StandardFonts.Helvetica);
+        for (const { field, value } of mappings) {
+            if (!value || String(value).trim() === '')
+                continue;
+            const pageIndex = field.pageNumber - 1;
+            if (pageIndex < 0 || pageIndex >= pdfDoc.getPageCount())
+                continue;
+            this.drawFieldText(pdfDoc.getPage(pageIndex), field, String(value), font);
+        }
+        const savedBytes = await pdfDoc.save({ useObjectStreams: true });
+        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+        fs.writeFileSync(outputPath, savedBytes);
+    }
+    /** Merge multiple PDFs into one */
+    static async mergePdfs(pdfPaths, outputPath) {
+        const merged = await PDFDocument.create();
+        for (const p of pdfPaths) {
+            const bytes = fs.readFileSync(p);
+            const src = await PDFDocument.load(bytes);
+            const pages = await merged.copyPages(src, src.getPageIndices());
+            pages.forEach(page => merged.addPage(page));
+        }
+        const savedBytes = await merged.save({ useObjectStreams: true });
+        fs.mkdirSync(path.dirname(outputPath), { recursive: true });
+        fs.writeFileSync(outputPath, savedBytes);
+    }
+    // ── Internal helpers ──
+    static drawFieldText(page, field, text, font) {
+        const { width: pageWidth, height: pageHeight } = page.getSize();
+        const x = (field.x / 100) * pageWidth;
+        const y = pageHeight - ((field.y / 100) * pageHeight) - ((field.height / 100) * pageHeight);
+        const w = (field.width / 100) * pageWidth;
+        const h = (field.height / 100) * pageHeight;
+        const sanitized = this.sanitize(text);
+        if (!sanitized)
+            return;
+        const pad = 2;
+        const maxW = w - pad * 2;
+        const maxH = h - pad * 2;
+        const desiredMax = field.fontSize ?? 14;
+        const minSize = 6;
+        const overflowMode = field.overflowMode ?? 'shrink';
+        if (overflowMode === 'wrap') {
+            let fs = desiredMax;
+            let lines = this.wrapText(sanitized, maxW, font, fs);
+            let totalH = lines.length * font.heightAtSize(fs) * 1.15;
+            while (totalH > maxH && fs > minSize) {
+                fs -= 0.5;
+                lines = this.wrapText(sanitized, maxW, font, fs);
+                totalH = lines.length * font.heightAtSize(fs) * 1.15;
+            }
+            if (lines.length === 0)
+                return;
+            const lineH = font.heightAtSize(fs) * 1.15;
+            const startY = y + h - pad - font.heightAtSize(fs);
+            const vOff = Math.max(0, (maxH - lines.length * lineH) / 2);
+            for (let i = 0; i < lines.length; i++) {
+                const ly = startY - i * lineH - vOff;
+                if (ly < y)
+                    break;
+                page.drawText(lines[i], { x: x + pad, y: ly, size: fs, font, color: rgb(0, 0, 0) });
+            }
+        }
+        else {
+            const fs = this.optimalFontSize(sanitized, maxW, maxH, font, minSize, desiredMax);
+            const fits = font.widthOfTextAtSize(sanitized, fs) <= maxW;
+            if (fits) {
+                const th = font.heightAtSize(fs);
+                page.drawText(sanitized, { x: x + pad, y: y + (h - th) / 2, size: fs, font, color: rgb(0, 0, 0) });
+            }
+            else {
+                // Fallback to wrap
+                const lines = this.wrapText(sanitized, maxW, font, fs);
+                const lineH = font.heightAtSize(fs) * 1.15;
+                const startY = y + h - pad - font.heightAtSize(fs);
+                const vOff = Math.max(0, (maxH - lines.length * lineH) / 2);
+                for (let i = 0; i < lines.length; i++) {
+                    const ly = startY - i * lineH - vOff;
+                    if (ly < y)
+                        break;
+                    page.drawText(lines[i], { x: x + pad, y: ly, size: fs, font, color: rgb(0, 0, 0) });
+                }
+            }
+        }
+    }
+    static sanitize(input) {
+        let t = String(input ?? '').trim();
+        t = t.replace(/[\u0000-\u0008\u000B\u000C\u000E-\u001F\u007F-\u009F]/g, '');
+        t = t.replace(/\s+/g, ' ');
+        t = t.replace(/[\u{1F600}-\u{1F64F}]|[\u{1F300}-\u{1F5FF}]|[\u{1F680}-\u{1F6FF}]|[\u{1F1E0}-\u{1F1FF}]|[\u{2600}-\u{26FF}]|[\u{2700}-\u{27BF}]/gu, '');
+        if (t.length > 500)
+            t = t.substring(0, 500);
+        return t;
+    }
+    static optimalFontSize(text, maxW, maxH, font, min, max) {
+        let s = max;
+        while (s >= min) {
+            if (font.widthOfTextAtSize(text, s) <= maxW && font.heightAtSize(s) <= maxH)
+                return s;
+            s -= 0.5;
+        }
+        return min;
+    }
+    static wrapText(text, maxW, font, fontSize) {
+        if (maxW <= 0 || fontSize <= 0)
+            return [text];
+        const lines = [];
+        let remaining = text;
+        let safety = 0;
+        while (remaining.length > 0 && safety < text.length + 10) {
+            safety++;
+            try {
+                if (font.widthOfTextAtSize(remaining, fontSize) <= maxW) {
+                    lines.push(remaining);
+                    break;
+                }
+            }
+            catch {
+                break;
+            }
+            let cut = 0;
+            const words = remaining.split(' ');
+            let test = '';
+            for (let w = 0; w < words.length; w++) {
+                const c = w === 0 ? words[w] : test + ' ' + words[w];
+                try {
+                    if (font.widthOfTextAtSize(c, fontSize) <= maxW) {
+                        test = c;
+                        cut = c.length;
+                    }
+                    else
+                        break;
+                }
+                catch {
+                    break;
+                }
+            }
+            if (cut === 0) {
+                for (let c = 1; c <= remaining.length; c++) {
+                    try {
+                        if (font.widthOfTextAtSize(remaining.substring(0, c), fontSize) > maxW) {
+                            cut = Math.max(1, c - 1);
+                            break;
+                        }
+                        cut = c;
+                    }
+                    catch {
+                        break;
+                    }
+                }
+            }
+            if (cut <= 0)
+                cut = 1;
+            lines.push(remaining.substring(0, cut));
+            remaining = remaining.substring(cut).trimStart();
+        }
+        return lines;
+    }
+}

package/dist/services/templateStore.d.ts

@@ -0,0 +1,20 @@
+import { SavedTemplate, TemplatePreview } from '../types.js';
+/**
+ * Filesystem-based template storage.
+ * Templates are stored as individual JSON files in the templates/ directory.
+ */
+export declare class TemplateStore {
+    private static ensureDir;
+    static list(): TemplatePreview[];
+    static load(templateName: string): SavedTemplate | null;
+    static save(template: SavedTemplate): string;
+    /** Get the path to the PDF file for a template */
+    static getPdfPath(template: SavedTemplate): string;
+    /**
+     * Import a template JSON exported from the web app.
+     * The web app stores the PDF as base64 in pdfInfo.dataUrl — we extract it to a file.
+     */
+    static importFromWebApp(jsonFilePath: string): SavedTemplate;
+    /** Build a minimal TemplateAnalysis from fields */
+    private static buildAnalysis;
+}

package/dist/services/templateStore.js

@@ -0,0 +1,137 @@
+import * as fs from 'fs';
+import * as path from 'path';
+const TEMPLATES_DIR = path.resolve(import.meta.dirname, '../../templates');
+/**
+ * Filesystem-based template storage.
+ * Templates are stored as individual JSON files in the templates/ directory.
+ */
+export class TemplateStore {
+    static ensureDir() {
+        fs.mkdirSync(TEMPLATES_DIR, { recursive: true });
+    }
+    static list() {
+        this.ensureDir();
+        const files = fs.readdirSync(TEMPLATES_DIR).filter(f => f.endsWith('.json'));
+        const previews = [];
+        for (const file of files) {
+            try {
+                const content = fs.readFileSync(path.join(TEMPLATES_DIR, file), 'utf-8');
+                const template = JSON.parse(content);
+                previews.push({
+                    name: template.name,
+                    description: template.description,
+                    createdAt: template.createdAt,
+                    fieldCount: template.fields.length,
+                    pageCount: template.pdfInfo.pageCount,
+                    requiredColumns: template.analysis.requiredColumns
+                });
+            }
+            catch {
+                // Skip corrupt files
+            }
+        }
+        return previews;
+    }
+    static load(templateName) {
+        this.ensureDir();
+        const safeName = templateName.replace(/[^a-zA-Z0-9_\-]/g, '_');
+        const filePath = path.join(TEMPLATES_DIR, `${safeName}.json`);
+        if (!fs.existsSync(filePath)) {
+            // Try matching by name field in all templates
+            const files = fs.readdirSync(TEMPLATES_DIR).filter(f => f.endsWith('.json'));
+            for (const file of files) {
+                try {
+                    const content = fs.readFileSync(path.join(TEMPLATES_DIR, file), 'utf-8');
+                    const t = JSON.parse(content);
+                    if (t.name.toLowerCase() === templateName.toLowerCase())
+                        return t;
+                }
+                catch { /* skip */ }
+            }
+            return null;
+        }
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    static save(template) {
+        this.ensureDir();
+        const safeName = template.name.replace(/[^a-zA-Z0-9_\-]/g, '_');
+        const filePath = path.join(TEMPLATES_DIR, `${safeName}.json`);
+        fs.writeFileSync(filePath, JSON.stringify(template, null, 2));
+        return filePath;
+    }
+    /** Get the path to the PDF file for a template */
+    static getPdfPath(template) {
+        return template.pdfPath;
+    }
+    /**
+     * Import a template JSON exported from the web app.
+     * The web app stores the PDF as base64 in pdfInfo.dataUrl — we extract it to a file.
+     */
+    static importFromWebApp(jsonFilePath) {
+        const content = fs.readFileSync(jsonFilePath, 'utf-8');
+        const parsed = JSON.parse(content);
+        // The web app export wraps in { exportedAt, version, ...templateData }
+        const templateData = parsed.id ? parsed : { ...parsed };
+        if (!templateData.name || !templateData.fields || !templateData.pdfInfo) {
+            throw new Error('Formato de template invalido. Asegurese de exportar desde la app web.');
+        }
+        // Extract PDF from base64 dataUrl
+        const dataUrl = templateData.pdfInfo.dataUrl;
+        if (!dataUrl) {
+            throw new Error('El template no contiene el PDF embebido (dataUrl)');
+        }
+        this.ensureDir();
+        const safeName = templateData.name.replace(/[^a-zA-Z0-9_\-]/g, '_');
+        const pdfFileName = `${safeName}.pdf`;
+        const pdfPath = path.join(TEMPLATES_DIR, pdfFileName);
+        // Decode base64 and save PDF
+        const base64Data = dataUrl.split(',')[1] || dataUrl;
+        const pdfBuffer = Buffer.from(base64Data, 'base64');
+        fs.writeFileSync(pdfPath, pdfBuffer);
+        // Create template without the large dataUrl
+        const template = {
+            id: `template_${Date.now()}_${Math.random().toString(36).substring(2, 9)}`,
+            name: templateData.name,
+            description: templateData.description || '',
+            createdAt: new Date().toISOString(),
+            updatedAt: new Date().toISOString(),
+            version: templateData.version || '1.0.0',
+            pdfPath,
+            pdfInfo: {
+                name: templateData.pdfInfo.name,
+                size: pdfBuffer.length,
+                pageCount: templateData.pdfInfo.pageCount
+            },
+            fields: templateData.fields,
+            analysis: templateData.analysis || this.buildAnalysis(templateData.fields),
+            metadata: { totalUsages: 0 }
+        };
+        // Save template JSON
+        this.save(template);
+        return template;
+    }
+    /** Build a minimal TemplateAnalysis from fields */
+    static buildAnalysis(fields) {
+        const groups = {};
+        for (const f of fields) {
+            const name = f.fieldName || f.name;
+            if (!groups[name])
+                groups[name] = { fieldName: name, count: 0, fields: [], pageDistribution: {} };
+            groups[name].count++;
+            groups[name].fields.push(f);
+            groups[name].pageDistribution[f.pageNumber] = (groups[name].pageDistribution[f.pageNumber] || 0) + 1;
+        }
+        const fieldGroups = Object.values(groups);
+        const counts = fieldGroups.map((g) => g.count);
+        return {
+            totalFields: fields.length,
+            fieldGroups,
+            documentCapacity: fieldGroups.reduce((s, g) => s + g.count, 0),
+            maxFieldCount: Math.max(...counts, 0),
+            minFieldCount: Math.min(...counts, 0),
+            requiredColumns: fieldGroups.map((g) => g.fieldName),
+            isBalanced: new Set(counts).size <= 1
+        };
+    }
+}

package/dist/tools/detectFields.d.ts

@@ -0,0 +1,20 @@
+export declare const detectFieldsSchema: {
+    name: string;
+    description: string;
+    inputSchema: {
+        type: "object";
+        properties: {
+            pdf_path: {
+                type: string;
+                description: string;
+            };
+        };
+        required: string[];
+    };
+};
+export declare function handleDetectFields(args: any): Promise<{
+    content: {
+        type: "text";
+        text: string;
+    }[];
+}>;

package/dist/tools/detectFields.js

@@ -0,0 +1,41 @@
+import { PdfService } from '../services/pdfService.js';
+export const detectFieldsSchema = {
+    name: 'autoform_detect_fields',
+    description: `Detecta campos de formulario AcroForm en un PDF interactivo (creado con Adobe Acrobat, LibreOffice, etc).
+
+CUANDO USAR: El PDF es un formulario donde puedes hacer click y escribir. Si el PDF es una imagen/diseño estatico (certificado, diploma), esta tool dira "sin campos" — en ese caso usa autoform_get_pdf_info + analisis visual.
+
+DESPUES DE DETECTAR: Usa autoform_fill_pdf para llenar los campos encontrados.`,
+    inputSchema: {
+        type: 'object',
+        properties: {
+            pdf_path: {
+                type: 'string',
+                description: 'Ruta absoluta al archivo PDF'
+            }
+        },
+        required: ['pdf_path']
+    }
+};
+export async function handleDetectFields(args) {
+    const { pdf_path } = args;
+    const { fields, hasAcroform } = await PdfService.detectFields(pdf_path);
+    let summary;
+    if (fields.length === 0) {
+        summary = `El PDF "${pdf_path}" no contiene campos AcroForm.\n\nPara usar este PDF, defina los campos manualmente en la app web de AutoForm y exporte la plantilla como JSON. Luego impórtela con autoform_import_template.`;
+    }
+    else {
+        summary = `Encontrados ${fields.length} campos AcroForm:\n\n${fields.map(f => `- ${f.name} (${f.type}) — Pag ${f.page}, pos: ${Math.round(f.x)},${Math.round(f.y)} ${Math.round(f.width)}x${Math.round(f.height)}${f.value ? ` = "${f.value}"` : ''}`).join('\n')}`;
+    }
+    return {
+        content: [{
+                type: 'text',
+                text: JSON.stringify({
+                    has_acroform: hasAcroform,
+                    total_fields: fields.length,
+                    fields,
+                    summary
+                }, null, 2)
+            }]
+    };
+}