autoform-mcp-server 1.6.0 → 1.6.1

package/dist/index.js

@@ -13,7 +13,7 @@ import { handleGenerateBatch, generateBatchSchema } from './tools/generateBatch.
 import { handleListTemplates, listTemplatesSchema } from './tools/manageTemplates.js';
 import { handleImportTemplate, importTemplateSchema } from './tools/importTemplate.js';
 import { withMetrics } from './services/metricsLogger.js';
-const server = new Server({ name: 'autoform', version: '1.6.0' }, { capabilities: { tools: {} } });
+const server = new Server({ name: 'autoform', version: '1.6.1' }, { capabilities: { tools: {} } });
 // Register all tools
 server.setRequestHandler(ListToolsRequestSchema, async () => ({
     tools: [
@@ -78,4 +78,4 @@ server.setRequestHandler(CallToolRequestSchema, async (request) => {
 // Start server
 const transport = new StdioServerTransport();
 await server.connect(transport);
-console.error('[AutoForm MCP] Server v1.6.0 started — 11 tools registered (metrics enabled)');
+console.error('[AutoForm MCP] Server v1.6.1 started — 11 tools registered (metrics enabled)');

package/dist/services/pdfTextExtractor.d.ts

@@ -11,16 +11,31 @@ export interface TextItem {
     page: number;
 }
 /**
- * Horizontal line detected as a drawing operator.
+ * A graphic element detected from PDF drawing operators.
  */
-export interface HorizontalLine {
+export interface GraphicElement {
+    type: 'checkbox' | 'field_box' | 'horizontal_line' | 'rectangle';
     x: number;
     y: number;
     width: number;
+    height: number;
     page: number;
+    nearbyLabel?: string;
+    labelPosition?: 'left' | 'right' | 'above' | 'below';
 }
 /**
- * A page's extracted information.
+ * Complete page information including text AND graphic elements.
+ */
+export interface PageFullInfo {
+    page: number;
+    width: number;
+    height: number;
+    textItems: TextItem[];
+    graphicElements: GraphicElement[];
+    totalCharacters: number;
+}
+/**
+ * A page's extracted information (text only, for backward compatibility).
  */
 export interface PageTextInfo {
     page: number;
@@ -40,6 +55,19 @@ export type PdfContentType = 'acroform' | 'text_vectorial' | 'image_only' | 'mix
 export declare class PdfTextExtractor {
     /** Extract all text items from all pages of a PDF */
     static extractAllText(pdfPath: string): Promise<PageTextInfo[]>;
+    /**
+     * Extract ALL information from a PDF: text items + graphic elements (rectangles, lines).
+     * Uses both getTextContent() and getOperatorList() to build a complete map of the page.
+     *
+     * Graphic elements are classified as:
+     * - checkbox: small square (6-16pt per side), likely a check box
+     * - field_box: medium/large rectangle (width > 40pt), likely an input field area
+     * - horizontal_line: very thin rectangle (height < 2pt, width > 30pt), likely an underline for writing
+     * - rectangle: anything else
+     *
+     * Each graphic element gets a nearbyLabel from the closest text item.
+     */
+    static extractFullPageInfo(pdfPath: string): Promise<PageFullInfo[]>;
     /**
      * Classify a PDF based on extractable text density.
      * Thresholds are empirical; can be tuned.

package/dist/services/pdfTextExtractor.js

@@ -55,6 +55,184 @@ export class PdfTextExtractor {
         }
         return pages;
     }
+    /**
+     * Extract ALL information from a PDF: text items + graphic elements (rectangles, lines).
+     * Uses both getTextContent() and getOperatorList() to build a complete map of the page.
+     *
+     * Graphic elements are classified as:
+     * - checkbox: small square (6-16pt per side), likely a check box
+     * - field_box: medium/large rectangle (width > 40pt), likely an input field area
+     * - horizontal_line: very thin rectangle (height < 2pt, width > 30pt), likely an underline for writing
+     * - rectangle: anything else
+     *
+     * Each graphic element gets a nearbyLabel from the closest text item.
+     */
+    static async extractFullPageInfo(pdfPath) {
+        const bytes = fs.readFileSync(pdfPath);
+        const pdf = await pdfjsLib.getDocument({
+            data: new Uint8Array(bytes),
+            useSystemFonts: true,
+            verbosity: 0
+        }).promise;
+        const results = [];
+        for (let pageNum = 1; pageNum <= pdf.numPages; pageNum++) {
+            const page = await pdf.getPage(pageNum);
+            const viewport = page.getViewport({ scale: 1 });
+            // 1. Extract text (same as extractAllText)
+            const textContent = await page.getTextContent();
+            const textItems = [];
+            let totalChars = 0;
+            for (const raw of textContent.items) {
+                const text = String(raw.str ?? '').trim();
+                if (text === '')
+                    continue;
+                const [, , , scaleY, tx, ty] = raw.transform;
+                const fontSize = Math.abs(scaleY);
+                const width = Math.abs(raw.width ?? 0);
+                const height = Math.abs(raw.height ?? fontSize);
+                textItems.push({ text, x: tx, y: ty, width, height, fontSize, page: pageNum });
+                totalChars += text.length;
+            }
+            // 2. Extract graphic elements from operator list
+            const operatorList = await page.getOperatorList();
+            const graphicElements = [];
+            // pdfjs OPS constants
+            const OPS = pdfjsLib.OPS;
+            // Track current transform matrix for coordinate conversion
+            // The operator list contains transform operations + rectangle draws
+            let currentTransform = [1, 0, 0, 1, 0, 0]; // identity
+            for (let i = 0; i < operatorList.fnArray.length; i++) {
+                const fn = operatorList.fnArray[i];
+                const args = operatorList.argsArray[i];
+                // Track transform changes
+                if (fn === OPS.transform) {
+                    if (args && args.length >= 6) {
+                        currentTransform = args;
+                    }
+                }
+                // Detect rectangle operations: constructPath contains 'rectangle' ops
+                if (fn === OPS.constructPath) {
+                    const ops = args[0]; // array of sub-operations
+                    const pathArgs = args[1]; // array of coordinates [x, y, w, h, ...]
+                    if (!ops || !pathArgs)
+                        continue;
+                    let argIdx = 0;
+                    for (const op of ops) {
+                        // op 13 = rectangle in pdfjs (OPS.rectangle)
+                        if (op === 13 && argIdx + 3 < pathArgs.length) {
+                            const rx = pathArgs[argIdx];
+                            const ry = pathArgs[argIdx + 1];
+                            const rw = pathArgs[argIdx + 2];
+                            const rh = pathArgs[argIdx + 3];
+                            // Apply current transform to get absolute coordinates
+                            const absX = currentTransform[4] + rx * currentTransform[0];
+                            const absY = currentTransform[5] + ry * currentTransform[3];
+                            const absW = Math.abs(rw * currentTransform[0]);
+                            const absH = Math.abs(rh * currentTransform[3]);
+                            // Filter: skip tiny rects (artifacts) and page-sized rects (backgrounds)
+                            if (absW < 4 || absH < 1) {
+                                argIdx += 4;
+                                continue;
+                            }
+                            if (absW > viewport.width * 0.95 && absH > viewport.height * 0.95) {
+                                argIdx += 4;
+                                continue;
+                            }
+                            // Classify the rectangle
+                            let type;
+                            if (absH < 2.5 && absW > 30) {
+                                type = 'horizontal_line';
+                            }
+                            else if (absW >= 6 && absW <= 25 && absH >= 6 && absH <= 25 && Math.abs(absW - absH) < 6) {
+                                type = 'checkbox';
+                            }
+                            else if (absW > 50 && absH > 10 && absH < 40) {
+                                type = 'field_box';
+                            }
+                            else {
+                                type = 'rectangle';
+                            }
+                            graphicElements.push({
+                                type,
+                                x: Math.round(absX * 100) / 100,
+                                y: Math.round(absY * 100) / 100,
+                                width: Math.round(absW * 100) / 100,
+                                height: Math.round(absH * 100) / 100,
+                                page: pageNum
+                            });
+                            argIdx += 4;
+                        }
+                        else {
+                            // Other path ops: moveTo(2 args), lineTo(2 args), etc.
+                            if (op === 14 || op === 15)
+                                argIdx += 2; // moveTo, lineTo
+                            else if (op === 16)
+                                argIdx += 6; // bezierCurveTo
+                            else if (op === 17)
+                                argIdx += 0; // closePath
+                            else
+                                argIdx += 2; // safe default
+                        }
+                    }
+                }
+            }
+            // 2.5. Deduplicate overlapping graphic elements of the same type
+            // PDFs often have multiple border layers for the same visual element
+            const deduped = [];
+            for (const elem of graphicElements) {
+                const isDuplicate = deduped.some(existing => existing.type === elem.type &&
+                    existing.page === elem.page &&
+                    Math.abs(existing.x - elem.x) < 8 &&
+                    Math.abs(existing.y - elem.y) < 8 &&
+                    Math.abs(existing.width - elem.width) < 10 &&
+                    Math.abs(existing.height - elem.height) < 10);
+                if (!isDuplicate)
+                    deduped.push(elem);
+            }
+            graphicElements.length = 0;
+            graphicElements.push(...deduped);
+            // 3. Correlate each graphic element with the nearest text label
+            for (const elem of graphicElements) {
+                const elemCenterX = elem.x + elem.width / 2;
+                const elemCenterY = elem.y + elem.height / 2;
+                let bestLabel = '';
+                let bestDist = Infinity;
+                let bestPos = 'left';
+                for (const ti of textItems) {
+                    const textCenterX = ti.x + ti.width / 2;
+                    const textCenterY = ti.y + ti.height / 2;
+                    const dx = elemCenterX - textCenterX;
+                    const dy = elemCenterY - textCenterY;
+                    const dist = Math.sqrt(dx * dx + dy * dy);
+                    if (dist < bestDist && dist < 200) { // max 200pt search radius
+                        bestDist = dist;
+                        bestLabel = ti.text;
+                        const absDx = Math.abs(dx);
+                        const absDy = Math.abs(dy);
+                        if (absDx > absDy) {
+                            bestPos = dx > 0 ? 'left' : 'right';
+                        }
+                        else {
+                            bestPos = dy > 0 ? 'below' : 'above';
+                        }
+                    }
+                }
+                if (bestLabel) {
+                    elem.nearbyLabel = bestLabel;
+                    elem.labelPosition = bestPos;
+                }
+            }
+            results.push({
+                page: pageNum,
+                width: viewport.width,
+                height: viewport.height,
+                textItems,
+                graphicElements,
+                totalCharacters: totalChars
+            });
+        }
+        return results;
+    }
     /**
      * Classify a PDF based on extractable text density.
      * Thresholds are empirical; can be tuned.

package/dist/tools/analyzeStaticPdf.js

@@ -21,11 +21,18 @@ Si recibes este tipo, NO intentes procesar el PDF con los otros tools. En su lug
 3. Proporcionar coordenadas manualmente si ya las conoces
 
 ⚠️ CASO text_vectorial:
-- suggested_fields son SUGERENCIAS heuristicas (asumen layout "Label: ___" a la derecha).
-- Para layouts atipicos (certificados con campo DEBAJO del label, diplomas con layout centrado, etc.) las sugerencias pueden estar en posiciones incorrectas.
-- USA all_text_items para ver TODOS los textos del PDF con sus posiciones exactas y razona sobre el layout real antes de decidir las coordenadas finales.
-- Los campos "CERTIFICADO", "Firma 1/2" que se detectan como sugerencias probablemente NO son campos editables — son etiquetas del certificado. Descarta sugerencias que claramente son texto decorativo.
-- Cuando no estes seguro, PREGUNTA al usuario donde va cada dato en lugar de adivinar.
+- suggested_fields son SUGERENCIAS heuristicas que pueden estar en posiciones incorrectas para layouts atipicos (centrados, tabulares complejos).
+- USA all_text_items para razonar sobre el layout real del PDF.
+- Descarta sugerencias que son texto decorativo ("CERTIFICADO", "Firma 1/2").
+- Cuando no estes seguro del layout, PREGUNTA al usuario o pidele que adjunte el PDF al chat para verlo visualmente.
+
+⚠️ FORMULARIOS COMPLEJOS:
+- Si el formulario tiene muchos campos (>10), tablas densas, o un layout no obvio, RECOMIENDA al usuario adjuntar el PDF al chat para verificacion visual antes de generar. Dile algo como: "Este formulario es complejo. Para asegurar precision, te recomiendo adjuntarme el PDF al chat para que pueda verificar las posiciones visualmente."
+- Si el usuario ya adjunto el PDF al chat Y tambien te dio la ruta, APROVECHA ambos: usa la imagen visual para verificar que tus coordenadas son correctas.
+
+⚠️ CHECKBOXES:
+- Si detectas textos tipo opciones multiples en la misma linea Y (ej: "ALUMNO", "DOCENTE", "ADMINISTRATIVO"), es probable que haya casillas de verificacion.
+- NO adivines la posicion de los cuadrados. Pide al usuario que adjunte el PDF para verlo visualmente.
 
 ⚠️ CASO mixed:
 Hay algo de texto pero poca densidad. Puede haber campos que NO se detectaron automaticamente porque el label es una imagen. Usa suggested_fields como punto de partida pero verifica visualmente si faltan campos.`,
@@ -127,7 +134,7 @@ export async function handleAnalyzeStaticPdf(args) {
     })));
     const summary = suggestedFields.length > 0
         ? `Se detectaron ${suggestedFields.length} campos candidatos automaticamente:\n${suggestedFields.map(f => `- "${f.inferredLabel}" en pag ${f.page}, pos (${f.suggestedX}, ${f.suggestedY}), ${f.suggestedWidth}x${f.suggestedHeight} [${f.confidence}]`).join('\n')}`
-        : 'No se detectaron campos candidatos automaticamente. El PDF tiene texto pero no hay patrones claros de "Label: ___" reconocibles.';
+        : 'No se detectaron campos candidatos automaticamente. El PDF tiene texto pero no hay patrones claros de "Label: ___" reconocibles. Revisa all_text_items para ver todo el texto del PDF con posiciones y razona sobre el layout.';
     return {
         content: [{
                 type: 'text',
@@ -143,14 +150,14 @@ export async function handleAnalyzeStaticPdf(args) {
                     },
                     total_text_items: allTextItems.length,
                     suggested_fields: suggestedFields,
-                    all_text_items: allTextItems.slice(0, 100), // Limit to avoid huge responses
+                    all_text_items: allTextItems.slice(0, 100),
                     text_items_truncated: allTextItems.length > 100,
                     summary,
                     guidance: contentType === 'mixed'
-                        ? 'El PDF tiene densidad baja de texto — puede tener elementos visuales (titulos como imagen, logos) que no se extraen. Usa los suggested_fields como punto de partida pero verifica si faltan campos.'
+                        ? 'El PDF tiene densidad baja de texto. Usa all_text_items como referencia y pregunta al usuario si faltan campos.'
                         : suggestedFields.length > 0
-                            ? 'Usa los suggested_fields directamente con autoform_fill_at_coordinates (un documento) o autoform_fill_batch_at_coordinates (multiples documentos).'
-                            : 'No hay campos obvios detectables. Pregunta al usuario donde quiere colocar los datos o pidele que abra el PDF en la app web de AutoForm.'
+                            ? 'Usa los suggested_fields como punto de partida. IMPORTANTE SOBRE CHECKBOXES: si detectas en all_text_items textos que parecen opciones multiples en la misma linea (ej: "ALUMNO", "DOCENTE", "ADMINISTRATIVO" con coordenadas Y similares), es MUY probable que el formulario tenga casillas de verificacion. En ese caso, NO adivines la posicion de los cuadrados — pide al usuario que adjunte el PDF al chat para que puedas verlo visualmente y determinar la posicion exacta de cada casilla antes de marcar con "X".'
+                            : 'No hay campos obvios detectables por heuristicas. IMPORTANTE: si en all_text_items detectas textos que parecen opciones multiples (ej: varias opciones en la misma linea Y), probablemente hay casillas de verificacion cuya posicion exacta no puedo determinar solo con texto. Pide al usuario que adjunte el PDF al chat para verlo visualmente, o que te indique donde estan las casillas.'
                 }, null, 2)
             }]
     };

package/dist/tools/fillAtCoordinates.js

@@ -1,31 +1,24 @@
 import * as path from 'path';
-import * as os from 'os';
 import { PdfService } from '../services/pdfService.js';
-const OUTPUT_DIR = path.join(os.homedir(), '.autoform-mcp', '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.
+    description: `Escribe texto en posiciones exactas de UN PDF.
 
-⚠️ ESTA TOOL ES PARA UN UNICO DOCUMENTO. Si necesitas generar multiples PDFs con los mismos campos pero datos diferentes, USA autoform_fill_batch_at_coordinates (mas eficiente, una sola llamada).
+⚠️ PARA MULTIPLES DOCUMENTOS usa autoform_fill_batch_at_coordinates (una sola llamada, mas eficiente).
 
-IMPORTANTE — Codificación de texto:
-- El texto se pasa EXACTAMENTE como lo envías. NO simplifiques ni modifiques caracteres.
-- Acentos españoles (á é í ó ú ñ Ñ ü) están soportados completamente.
-- Nombres como "Sofía", "Benítez", "Peña" deben pasarse con sus tildes intactas.
-- Solo se filtran: emojis, caracteres de control invisibles, y patrones de script malicioso.
+CODIFICACION: Acentos (á é í ó ú ñ Ñ ü) soportados. NO simplifiques caracteres.
 
-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
+CHECKBOXES: Solo marca casillas si puedes VER el PDF visualmente. Si no, pide al usuario que lo adjunte al chat.
 
-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`,
+VERIFICACION VISUAL: Si el usuario adjunto el PDF Y dio la ruta, aprovecha la imagen para verificar coordenadas antes de escribir.
+
+DIRECTORIO DE SALIDA: Si no se especifica output_path, guarda en el MISMO directorio del pdf_path original.
+
+NO GENERES PDF DE PRUEBA: Genera el resultado final directamente. No hagas "tests" individuales a menos que el usuario lo pida.
+
+CUANDO TENGAS DUDAS: Si el formulario es complejo y no estas seguro de las posiciones, PREGUNTA al usuario o pidele que adjunte el PDF al chat. Mejor preguntar que generar mal.
+
+COORDENADAS: Origen (0,0) = esquina inferior-izquierda. Y aumenta hacia arriba. Puntos PDF (A4 ≈ 595x842, Letter ≈ 612x792).`,
     inputSchema: {
         type: 'object',
         properties: {
@@ -89,7 +82,7 @@ export async function handleFillAtCoordinates(args) {
             isError: true
         };
     }
-    const outputFile = output_path || path.join(OUTPUT_DIR, `coords_${path.basename(pdf_path, '.pdf')}_${Date.now()}.pdf`);
+    const outputFile = output_path || path.join(path.dirname(pdf_path), `${path.basename(pdf_path, '.pdf')}_filled_${Date.now()}.pdf`);
     const filled = await PdfService.fillAtCoordinates(pdf_path, fields, outputFile);
     return {
         content: [{

package/dist/tools/fillBatchAcroForm.js

@@ -1,7 +1,5 @@
 import * as path from 'path';
-import * as os from 'os';
 import { PdfService } from '../services/pdfService.js';
-const OUTPUT_DIR = path.join(os.homedir(), '.autoform-mcp', 'output');
 export const fillBatchAcroFormSchema = {
     name: 'autoform_fill_batch_acroform',
     description: `Genera MULTIPLES PDFs a partir de un PDF con campos AcroForm (formulario interactivo) + array de datos. Una sola llamada genera N documentos.
@@ -17,9 +15,15 @@ IMPORTANTE sobre nombres de campos:
 - Si las claves de tus data_rows NO coinciden con los nombres tecnicos, usa el parametro field_map para traducir: { "nombre_logico": "nombre_tecnico" }
 - Ejemplo: si el campo tecnico es "Text1" pero visualmente corresponde al label "Nombre:", pasa field_map={"nombre": "Text1"} y data_rows=[{"nombre": "Juan"}]
 
-MERGE: Si merge_into_single=true, se genera SOLO el PDF unificado (los individuales son temporales y se borran automaticamente).
+MERGE: Si merge_into_single=true, se genera SOLO el PDF unificado.
 
-CODIFICACION: Los datos se escriben EXACTAMENTE como los envias. Acentos espanoles (a e i o u n N u con tildes) estan completamente soportados. NO simplifiques caracteres.`,
+CODIFICACION: Acentos (á é í ó ú ñ) soportados completamente. NO simplifiques caracteres.
+
+DIRECTORIO DE SALIDA: Si no se especifica output_dir, usa el MISMO directorio donde esta el pdf_path original.
+
+NO GENERES PDF DE PRUEBA: Genera el batch completo directamente. No hagas un "test" individual primero a menos que el usuario lo pida.
+
+VERIFICACION: Si el usuario adjunto el PDF al chat Y dio la ruta, aprovecha la imagen visual para verificar que los inferred_labels son correctos.`,
     inputSchema: {
         type: 'object',
         properties: {
@@ -74,7 +78,7 @@ export async function handleFillBatchAcroForm(args) {
             isError: true
         };
     }
-    const outDir = output_dir || OUTPUT_DIR;
+    const outDir = output_dir || path.dirname(pdf_path);
     const baseName = path.basename(pdf_path, '.pdf').replace(/[^a-zA-Z0-9_\-]/g, '_');
     const result = await PdfService.batchFillAcroForm(pdf_path, data_rows, outDir, baseName, merge_into_single, field_map);
     return {

package/dist/tools/fillBatchAtCoordinates.js

@@ -1,7 +1,5 @@
 import * as path from 'path';
-import * as os from 'os';
 import { PdfService } from '../services/pdfService.js';
-const OUTPUT_DIR = path.join(os.homedir(), '.autoform-mcp', '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.
@@ -11,16 +9,30 @@ CUANDO USAR: El usuario pasa un PDF (certificado, diploma, constancia) y una LIS
 IMPORTANTE — Codificación de texto:
 - Los datos se escriben EXACTAMENTE como los envías. NO simplifiques ni modifiques caracteres.
 - Acentos españoles (á é í ó ú ñ Ñ ü) están soportados completamente.
-- Nombres como "Sofía", "Benítez", "Peña" deben pasarse con sus tildes intactas.
+
+IMPORTANTE — Casillas de verificación (checkboxes) en PDFs estaticos:
+- Si detectas opciones tipo checkbox, SOLO marcalas si puedes VER el PDF visualmente (adjuntado al chat). Si no puedes verlo, pide al usuario que lo adjunte.
+- Para marcar: text="X", fontSize=10, en las coordenadas exactas del cuadrado.
+
+IMPORTANTE — Verificación visual:
+- Si el usuario adjunto el PDF al chat Y tambien dio la ruta, APROVECHA la imagen visual para verificar que tus coordenadas son correctas antes de generar.
+- Si tienes dudas sobre el layout de un formulario complejo (tablas densas, campos no claros), PREGUNTA al usuario antes de generar. Es mejor preguntar que generar mal.
+
+DIRECTORIO DE SALIDA POR DEFECTO:
+- Si el usuario NO especifica output_dir, usa el MISMO directorio donde esta el PDF base (pdf_path). No uses ~/.autoform-mcp/output/ por defecto — el usuario espera los archivos cerca de su PDF original.
+
+NO GENERES PDFs DE PRUEBA/TEST:
+- Genera directamente el batch completo. NO generes un "test" individual primero a menos que el usuario lo pida explicitamente. Generar tests innecesarios desperdicia tiempo y confunde al usuario con archivos extra.
 
 MERGE: Si merge_into_single=true, se genera SOLO el PDF unificado (los individuales son temporales y se borran automáticamente).
 
-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
+FLUJO CORRECTO:
+1. Usa autoform_get_pdf_info para dimensiones
+2. Si puedes ver el PDF (adjuntado al chat): analiza visualmente donde van los campos
+3. Si NO puedes verlo: usa autoform_analyze_static_pdf para obtener texto+posiciones, y si detectas posibles checkboxes o layout complejo, pide al usuario que adjunte el PDF
+4. Define los campos con coordenadas
+5. Genera el batch completo de una vez (NO hagas un test primero)
+6. Informa al usuario la ruta del resultado
 
 SISTEMA DE COORDENADAS: Origen (0,0) = esquina inferior-izquierda. Y aumenta hacia arriba. Unidades: puntos PDF.`,
     inputSchema: {
@@ -90,7 +102,7 @@ export async function handleFillBatchAtCoordinates(args) {
     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 outDir = output_dir || path.dirname(pdf_path);
     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 {

package/dist/tools/fillPdf.js

@@ -1,8 +1,6 @@
 import * as path from 'path';
-import * as os from 'os';
 import { PdfService } from '../services/pdfService.js';
 import { TemplateStore } from '../services/templateStore.js';
-const OUTPUT_DIR = path.join(os.homedir(), '.autoform-mcp', 'output');
 export const fillPdfSchema = {
     name: 'autoform_fill_pdf',
     description: `Llena UN SOLO PDF con valores. Detecta automaticamente si tiene AcroForm o usa un template guardado.
@@ -13,8 +11,10 @@ export const fillPdfSchema = {
   - Template guardado + multiples filas → autoform_generate_batch
 
 CUANDO USAR: Solo cuando el usuario pide llenar UN documento especifico.
-NO USAR PARA BATCH: Nunca llames esta tool en loop para generar multiples PDFs — usa las tools batch que existen para eso.
-NO USAR SI: El PDF es estatico sin template → usa autoform_fill_at_coordinates.`,
+NO USAR PARA BATCH: Nunca llames esta tool en loop — usa las tools batch.
+NO USAR SI: El PDF es estatico sin template → usa autoform_fill_at_coordinates.
+
+DIRECTORIO DE SALIDA: Si no se especifica output_path, guarda en el MISMO directorio del pdf_path original.`,
     inputSchema: {
         type: 'object',
         properties: {
@@ -48,7 +48,7 @@ export async function handleFillPdf(args) {
         }
         catch { /* keep as-is */ }
     }
-    const outputFile = output_path || path.join(OUTPUT_DIR, `filled_${path.basename(pdf_path, '.pdf')}_${Date.now()}.pdf`);
+    const outputFile = output_path || path.join(path.dirname(pdf_path), `${path.basename(pdf_path, '.pdf')}_filled_${Date.now()}.pdf`);
     // Try AcroForm first
     const { fields, hasAcroform } = await PdfService.detectFields(pdf_path);
     if (hasAcroform && fields.length > 0) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "autoform-mcp-server",
-  "version": "1.6.0",
+  "version": "1.6.1",
   "description": "MCP server for bulk PDF form filling. Detect fields, fill templates, and generate hundreds of PDFs from data — directly from Claude.",
   "type": "module",
   "main": "dist/index.js",