@sirdaspdf/core 0.1.0 → 0.3.0

package/dist/agentchunks.d.ts

@@ -0,0 +1,18 @@
+export interface AgentChunk {
+    /** Hash del contenido: el mismo texto da el mismo id en cualquier máquina. */
+    id: string;
+    index: number;
+    /** Primera y última página de las que sale el texto (base 1), o null si el Markdown no traía marcas. */
+    pages: [number, number] | null;
+    /** Ruta de encabezados, del más general al más concreto. */
+    section: string[];
+    text: string;
+    tokens: number;
+}
+/** Dos semillas: 64 bits de identificador bastan para no chocar en un corpus. */
+export declare function contentId(text: string): string;
+/**
+ * Parte Markdown (idealmente generado con `pageMarkers: true`) en trozos con
+ * procedencia. Las marcas de página se usan y se retiran del texto final.
+ */
+export declare function chunkForAgents(markdown: string, maxTokens?: number): AgentChunk[];

package/dist/agentchunks.js

@@ -0,0 +1,85 @@
+// Trozos para agentes: lo mismo que chunkMarkdown, más lo que un agente
+// necesita para citar y deduplicar sin volver a leer el PDF: de qué páginas
+// sale cada trozo, en qué sección cae y un identificador estable.
+import { chunkMarkdown } from "./chunk.js";
+import { estimateTokens, PAGE_MARKER } from "./markdown.js";
+const HEADING = /^(#{1,6})\s+(.+)$/;
+/** FNV-1a de 32 bits. Sin node:crypto, para que core siga cargando en el navegador. */
+function fnv1a(text, seed) {
+    let h = seed >>> 0;
+    for (let i = 0; i < text.length; i++) {
+        h ^= text.charCodeAt(i);
+        h = Math.imul(h, 0x01000193) >>> 0;
+    }
+    return h.toString(16).padStart(8, "0");
+}
+/** Dos semillas: 64 bits de identificador bastan para no chocar en un corpus. */
+export function contentId(text) {
+    return `fnv1a:${fnv1a(text, 0x811c9dc5)}${fnv1a(text, 0x050c5d1f)}`;
+}
+/** Ruta completa de cada encabezado, en el orden en que aparece. */
+function headingPaths(markdown) {
+    const paths = new Map();
+    const stack = [];
+    for (const line of markdown.split("\n")) {
+        const m = line.match(HEADING);
+        if (!m)
+            continue;
+        const level = m[1].length;
+        while (stack.length && stack[stack.length - 1].level >= level)
+            stack.pop();
+        stack.push({ level, text: m[2].trim() });
+        if (!paths.has(m[2].trim()))
+            paths.set(m[2].trim(), stack.map((s) => s.text));
+    }
+    return paths;
+}
+const stripMarkers = (text) => text
+    .split("\n")
+    .filter((l) => !PAGE_MARKER.test(l.trim()))
+    .join("\n")
+    .replace(/\n{3,}/g, "\n\n")
+    .trim();
+/**
+ * Parte Markdown (idealmente generado con `pageMarkers: true`) en trozos con
+ * procedencia. Las marcas de página se usan y se retiran del texto final.
+ */
+export function chunkForAgents(markdown, maxTokens = 2000) {
+    const hasMarkers = markdown.split("\n").some((l) => PAGE_MARKER.test(l.trim()));
+    const paths = headingPaths(markdown);
+    // El texto va en orden, así que la página vigente al empezar un trozo es la
+    // última marca vista en los trozos anteriores.
+    let current = 1;
+    const out = [];
+    for (const c of chunkMarkdown(markdown, maxTokens)) {
+        const lines = c.text.split("\n");
+        let first = null;
+        let last = current;
+        for (const line of lines) {
+            const m = line.trim().match(PAGE_MARKER);
+            if (m) {
+                current = Number(m[1]);
+                continue;
+            }
+            // Una marca al final del trozo pertenece al siguiente: solo cuenta la
+            // página si hay texto real después de ella.
+            if (line.trim() && !HEADING.test(line)) {
+                if (first === null)
+                    first = current;
+                last = current;
+            }
+        }
+        const text = stripMarkers(c.text);
+        if (!text)
+            continue;
+        out.push({
+            id: contentId(text),
+            index: out.length + 1,
+            pages: hasMarkers ? [first ?? current, Math.max(first ?? current, last)] : null,
+            section: c.heading ? (paths.get(c.heading) ?? [c.heading]) : [],
+            text,
+            tokens: estimateTokens(text),
+        });
+    }
+    return out;
+}

package/dist/anonymize.js

@@ -3,20 +3,52 @@ const MONTHS = "enero|febrero|marzo|abril|mayo|junio|julio|agosto|septiembre|set
 // se filtra. Cubrimos las partículas españolas ("de", "del", "de la/las/los")
 // y hasta siete palabras, que es lo que llega a tener un nombre compuesto
 // colombiano con dos apellidos.
-const PARTICLE = "(?:de\\s+(?:la|las|los)\\s+|del\\s+|de\\s+)?";
-const NAME = `[A-ZÁÉÍÓÚÑ][a-záéíóúñü]+(?:\\s+${PARTICLE}[A-ZÁÉÍÓÚÑ][a-záéíóúñü]+){1,6}`;
-const NAME_UPPER = "[A-ZÁÉÍÓÚÑ]{2,}(?:\\s+[A-ZÁÉÍÓÚÑ]{2,}){1,6}";
+// Los espacios dentro de un nombre son de la MISMA línea. Con \s+ el patrón
+// cruzaba el salto y «Paciente: Juan Carlos Perez Gomez» seguido de «Cedula de
+// ciudadania…» capturaba «…Perez Gomez Cedula» como un solo nombre, dejando la
+// palabra suelta sustituida en medio de la frase siguiente. Un párrafo ya llega
+// con sus líneas unidas, así que no se pierde ningún nombre real por esto.
+const SP = "[ \\t]+";
+const PARTICLE = `(?:de${SP}(?:la|las|los)${SP}|del${SP}|de${SP})?`;
+const NAME = `[A-ZÁÉÍÓÚÑ][a-záéíóúñü]+(?:${SP}${PARTICLE}[A-ZÁÉÍÓÚÑ][a-záéíóúñü]+){1,6}`;
+const NAME_UPPER = `[A-ZÁÉÍÓÚÑ]{2,}(?:${SP}[A-ZÁÉÍÓÚÑ]{2,}){1,6}`;
 /** Vuelve insensible a mayúsculas solo las etiquetas (el nombre sí distingue mayúsculas). */
 const ci = (src) => src.replace(/[a-záéíóúñ]/g, (ch) => `[${ch}${ch.toUpperCase()}]`);
 const NAME_LABELS = "nombres?(?:\\s+completo)?|paciente|usuario|afiliado|señora?|sr\\.|sra\\.|don|doña|comprador(?:a)?|vendedor(?:a)?|otorgante|compareciente|demandante|demandado|arrendador(?:a)?|arrendatario|apoderad[oa]|titular|firmado por|name|patient|client|signed by";
+/** Algoritmo de Luhn: todas las tarjetas lo cumplen; la mayoría de números al azar, no. */
+function luhn(value) {
+    const d = value.replace(/\D/g, "");
+    if (d.length < 13 || d.length > 19)
+        return false;
+    let sum = 0;
+    for (let i = 0; i < d.length; i++) {
+        let n = Number(d[d.length - 1 - i]);
+        if (i % 2)
+            n = n * 2 > 9 ? n * 2 - 9 : n * 2;
+        sum += n;
+    }
+    return sum % 10 === 0;
+}
+/** Números largos de documentos comerciales que no son tarjetas aunque pasen Luhn (1 de cada 10 lo hace por azar). */
+const NOT_A_CARD = /(resoluci[oó]n|cufe|cude|autorizaci[oó]n|radicado|factura|consecutivo|orden|pedido|gu[ií]a|referencia|c[oó]digo|matr[ií]cula|expediente)[^\n]{0,30}$/i;
 const RULES = [
     { type: "EMAIL", re: /[\w.+-]+@[\w-]+(?:\.[\w-]+)+/g },
-    { type: "HISTORIA_CLINICA", re: /\b(?:historia\s+cl[ií]nica|h\.?\s?c\.?|n[uú]mero\s+de\s+historia)\s*(?:n[oº°.]*|#|:)?\s*([A-Z0-9-]{4,})/gi, group: 1 },
+    // El separador NO puede cruzar una línea en blanco, y el número tiene que
+    // llevar al menos un dígito. Sin las dos condiciones, un título «Historia
+    // clínica» seguido de «Paciente: Fulano» capturaba la palabra «Paciente»
+    // como si fuera el número de historia, la sustituía en todo el documento y
+    // con eso rompía el patrón «Paciente: nombre»: el nombre quedaba a la vista.
+    {
+        type: "HISTORIA_CLINICA",
+        re: /\b(?:historia\s+cl[ií]nica|h\.?\s?c\.?|n[uú]mero\s+de\s+historia)[ \t]*(?:n[oº°.]*|#|:)?[ \t]*((?=[A-Z0-9-]*\d)[A-Z0-9-]{4,})/gi,
+        group: 1,
+    },
     { type: "NIT", re: /\b(?:NIT\.?\s*:?\s*)?\d{3}\.?\d{3}\.?\d{3}\s?-\s?\d\b/g },
-    { type: "TARJETA", re: /\b(?:\d{4}[ -]?){3}\d{1,4}\b/g },
+    { type: "TARJETA", re: /\b(?:\d{4}[ -]?){3}\d{1,4}\b/g, accept: (v, before) => luhn(v) && !NOT_A_CARD.test(before) },
     {
         type: "DOCUMENTO",
-        re: /\b(?:C\.?\s?C\.?|c[eé]dula(?:\s+de\s+ciudadan[ií]a)?|T\.?\s?I\.?|C\.?\s?E\.?|NUIP|pasaporte|DNI|RUT|CURP|RFC|ID)\s*(?:n[oº°.]*|#|:)?\s*([A-Z]{0,4}\d[\d.\s-]{4,14}\d)/gi,
+        // Mismo motivo que arriba: la etiqueta y el número van en la misma línea.
+        re: /\b(?:C\.?\s?C\.?|c[eé]dula(?:\s+de\s+ciudadan[ií]a)?|T\.?\s?I\.?|C\.?\s?E\.?|NUIP|pasaporte|DNI|RUT|CURP|RFC|ID)[ \t]*(?:n[oº°.]*|#|:)?[ \t]*([A-Z]{0,4}\d[\d.\s-]{4,14}\d)/gi,
         group: 1,
     },
     { type: "DOCUMENTO", re: /(?<![$€£\d.,]\s?)\b\d{1,3}(?:\.\d{3}){2,3}\b(?!\s*(?:pesos|cop|usd|millones|m²|m2))/gi },
@@ -36,7 +68,14 @@ const RULES = [
         type: "DIRECCION",
         re: /\b(?:calle|cll?|carrera|cra|kr|kra|avenida|av|transversal|tv|diagonal|dg|autopista|street|st|avenue|ave)\.?\s*\d+[a-z]?(?:\s*bis)?(?:\s*(?:sur|norte|este))?\s*(?:#|n[oº°.]*|no\.?)\s*\d+[a-z]?\s*-\s*\d+(?:\s*(?:sur|norte|este))?(?:[,\s]+(?:apto|apartamento|oficina|of|int|interior|casa|torre)\.?\s*[\w-]+)*/gi,
     },
-    { type: "NOMBRE", re: new RegExp(`(?:${ci(NAME_LABELS)})\\s*[:\\-]?\\s*(${NAME_UPPER}|${NAME})(?![a-záéíóúñ])`, "g"), group: 1 },
+    // Se admite un único salto de línea entre la etiqueta y el nombre («Paciente:»
+    // al final de una línea y el nombre en la siguiente), pero no una línea en
+    // blanco: eso ya es otro párrafo y capturarlo produce falsos positivos.
+    {
+        type: "NOMBRE",
+        re: new RegExp(`(?:${ci(NAME_LABELS)})[ \\t]*[:\\-]?[ \\t]*(?:\\r?\\n[ \\t]*)?(${NAME_UPPER}|${NAME})(?![a-záéíóúñ])`, "g"),
+        group: 1,
+    },
 ];
 export function anonymize(text) {
     const map = new Map();
@@ -61,6 +100,15 @@ export function anonymize(text) {
             const target = rule.group ? args[rule.group] : full;
             if (!target || target.startsWith("["))
                 return full;
+            if (rule.accept) {
+                // Firma de replace: (coincidencia, ...grupos, offset, cadena[, grupos con nombre]).
+                const named = typeof args[args.length - 1] === "object";
+                const offset = args[args.length - (named ? 3 : 2)];
+                const source = args[args.length - (named ? 2 : 1)];
+                const before = source.slice(source.lastIndexOf("\n", offset) + 1, offset);
+                if (!rule.accept(target, before))
+                    return full;
+            }
             if (rule.type === "NOMBRE" && /\[/.test(target))
                 return full;
             const label = labelFor(rule.type, target);

package/dist/classify.d.ts

@@ -0,0 +1,12 @@
+export type DocType = "factura" | "contrato" | "historia_clinica" | "cedula" | "rut" | "extracto_bancario" | "certificado" | "hoja_de_vida" | "desconocido";
+export interface Classification {
+    type: DocType;
+    /** 0–1. Proporción de señales del ganador frente al total; no es una probabilidad calibrada. */
+    confidence: number;
+    /** Señales encontradas, para que un humano pueda comprobar por qué. */
+    signals: string[];
+    /** Segundo candidato, útil cuando la confianza es baja. */
+    runnerUp: DocType | null;
+}
+/** Clasifica por el texto (basta con las primeras páginas). */
+export declare function classifyDocument(text: string): Classification;

package/dist/classify.js

@@ -0,0 +1,89 @@
+// Tipo de documento por reglas, sin modelo: un agente decide qué hacer con un
+// PDF (qué campos buscar, si anonimizar) antes de leerlo entero, y el contenido
+// nunca sale de la máquina para averiguarlo.
+const RULES = {
+    factura: [
+        [/factura\s+(electr[oó]nica\s+)?de\s+venta/i, 4],
+        [/\bcufe\b/i, 4],
+        [/\binvoice\b/i, 3],
+        [/\biva\b/i, 1],
+        [/subtotal/i, 2],
+        [/total\s+a\s+pagar/i, 2],
+        [/resoluci[oó]n\s+dian/i, 3],
+    ],
+    contrato: [
+        [/\bcontrato\s+de\b/i, 4],
+        [/cl[aá]usula\s+(primera|segunda|tercera|\d+)/i, 3],
+        [/\bel\s+contratante\b|\bel\s+contratista\b/i, 3],
+        [/\bpartes\b.*\bacuerdan\b/is, 2],
+        [/\bagreement\b|\bwhereas\b/i, 3],
+        [/en\s+constancia\s+se\s+firma/i, 2],
+    ],
+    historia_clinica: [
+        [/historia\s+cl[ií]nica/i, 4],
+        [/\bepicrisis\b/i, 4],
+        [/motivo\s+de\s+consulta/i, 3],
+        [/\bdiagn[oó]stico\b/i, 2],
+        [/\bcie-?10\b/i, 3],
+        [/signos\s+vitales|tensi[oó]n\s+arterial/i, 2],
+    ],
+    cedula: [
+        [/c[eé]dula\s+de\s+ciudadan[ií]a/i, 4],
+        [/registradur[ií]a\s+nacional/i, 4],
+        [/fecha\s+y\s+lugar\s+de\s+nacimiento/i, 2],
+        [/\bgrupo\s+sangu[ií]neo\b|\bG\.?S\.?\s*RH\b/i, 2],
+    ],
+    rut: [
+        [/registro\s+[uú]nico\s+tributario/i, 5],
+        [/formulario\s+del\s+registro/i, 2],
+        [/responsabilidades,?\s+calidades/i, 3],
+        [/direcci[oó]n\s+seccional/i, 2],
+    ],
+    extracto_bancario: [
+        [/extracto/i, 3],
+        [/saldo\s+(anterior|final|disponible)/i, 3],
+        [/movimientos/i, 2],
+        [/\bbank\s+statement\b/i, 4],
+        [/n[uú]mero\s+de\s+cuenta/i, 1],
+    ],
+    certificado: [
+        [/\bcertifica(do)?\b/i, 2],
+        [/hace\s+constar/i, 3],
+        [/certificado\s+de\s+(existencia|tradici[oó]n|ingresos|retenci[oó]n)/i, 4],
+    ],
+    hoja_de_vida: [
+        [/hoja\s+de\s+vida|curr[ií]culum/i, 4],
+        [/experiencia\s+(laboral|profesional)/i, 3],
+        [/formaci[oó]n\s+acad[eé]mica|educaci[oó]n/i, 2],
+        [/referencias\s+(personales|laborales)/i, 2],
+    ],
+};
+/** Clasifica por el texto (basta con las primeras páginas). */
+export function classifyDocument(text) {
+    const sample = text.slice(0, 20000);
+    const scores = [];
+    for (const [type, rules] of Object.entries(RULES)) {
+        let score = 0;
+        const signals = [];
+        for (const [re, weight] of rules) {
+            const m = sample.match(re);
+            if (m) {
+                score += weight;
+                signals.push(m[0].replace(/\s+/g, " ").trim().slice(0, 40));
+            }
+        }
+        scores.push({ type, score, signals });
+    }
+    scores.sort((a, b) => b.score - a.score);
+    const [best, second] = scores;
+    const total = scores.reduce((n, s) => n + s.score, 0);
+    // Por debajo de 3 puntos es una palabra suelta, no un documento de ese tipo.
+    if (best.score < 3)
+        return { type: "desconocido", confidence: 0, signals: [], runnerUp: best.score ? best.type : null };
+    return {
+        type: best.type,
+        confidence: Math.round((best.score / total) * 100) / 100,
+        signals: best.signals,
+        runnerUp: second.score ? second.type : null,
+    };
+}

package/dist/dataset.d.ts

@@ -2,7 +2,18 @@
  * Formatos de salida. Los nombres de campo son los que consumen los
  * entrenadores; cambiarlos rompe la carga del dataset, así que no se tocan.
  */
-export type DatasetFormat = "text" | "chat" | "prompt-completion";
+export type DatasetFormat = "text" | "chat" | "prompt-completion"
+/** Stanford Alpaca: instruction / input / output. Lo usan Axolotl, LLaMA-Factory y Unsloth. */
+ | "alpaca"
+/** ShareGPT: conversations con from human / gpt. */
+ | "sharegpt"
+/** Documentos de LangChain: page_content + metadata. */
+ | "langchain"
+/** TextNode de LlamaIndex: id_ + text + metadata. */
+ | "llamaindex"
+/** Para una base vectorial: id estable + text + metadata plana. */
+ | "embeddings";
+export declare const DATASET_FORMATS: DatasetFormat[];
 export interface SourceDocument {
     /** Nombre del archivo: es la clave del reparto y de la trazabilidad. */
     name: string;
@@ -54,6 +65,19 @@ export declare function buildRecords(docs: SourceDocument[], options?: BuildOpti
  * campos que no conocen, así que dejarla puesta sale gratis y permite rastrear
  * de qué página salió cada ejemplo cuando el modelo diga algo raro.
  */
+/**
+ * Tarjeta de dataset para Hugging Face (README.md con metadatos YAML). Un
+ * dataset sin tarjeta no dice de dónde salió ni qué se le quitó, y eso es justo
+ * lo que un equipo de ML necesita para confiar en él.
+ */
+export declare function datasetCard(stats: DatasetStats, opts: {
+    name?: string;
+    format: DatasetFormat;
+    language?: string;
+    splits?: string[];
+    anonymized: boolean;
+    deduplicated?: boolean;
+}): string;
 export declare function toJsonl(records: DatasetRecord[], withMeta?: boolean): string;
 export interface DatasetStats {
     records: number;

package/dist/dataset.js

@@ -5,9 +5,11 @@
 // Eso exigiría mandar tus documentos a una API, que es exactamente lo que este
 // producto existe para evitar. Aquí todo sale del documento por reglas, y cada
 // registro dice de dónde salió.
+import { contentId } from "./agentchunks.js";
 import { chunkMarkdown } from "./chunk.js";
 import { anonymize as redactPii } from "./anonymize.js";
 import { estimateTokens } from "./markdown.js";
+export const DATASET_FORMATS = ["text", "chat", "prompt-completion", "alpaca", "sharegpt", "langchain", "llamaindex", "embeddings"];
 const DEFAULT_TEMPLATE = "Resume el contenido de «{heading}» del documento {document}.";
 /** Un trozo sin encabezado no puede pedir «resume la sección “archivo.pdf”». */
 const DEFAULT_TEMPLATE_NO_HEADING = "Resume el contenido del documento {document}.";
@@ -46,13 +48,30 @@ export function buildRecords(docs, options = {}) {
             const hasHeading = (chunk.heading ?? "").trim() !== "";
             const tpl = options.template ?? (hasHeading ? DEFAULT_TEMPLATE : DEFAULT_TEMPLATE_NO_HEADING);
             const instruction = fillTemplate(tpl, { heading: chunk.heading ?? "", document: doc.name });
-            records.push({ data: shape(format, text, instruction, system), meta });
+            records.push({ data: shape(format, text, instruction, system, meta), meta });
         });
     }
     return records;
 }
-function shape(format, text, instruction, system) {
+function shape(format, text, instruction, system, meta) {
+    const metadata = meta ? { source: meta.document, chunk: meta.chunk, heading: meta.heading, tokens: meta.tokens } : {};
     switch (format) {
+        case "alpaca":
+            return { instruction, input: "", output: text, ...(system ? { system } : {}) };
+        case "sharegpt":
+            return {
+                conversations: [
+                    ...(system ? [{ from: "system", value: system }] : []),
+                    { from: "human", value: instruction },
+                    { from: "gpt", value: text },
+                ],
+            };
+        case "langchain":
+            return { page_content: text, metadata, type: "Document" };
+        case "llamaindex":
+            return { id_: contentId(text), text, metadata, class_name: "TextNode" };
+        case "embeddings":
+            return { id: contentId(text), text, metadata };
         case "text":
             return { text };
         case "prompt-completion":
@@ -75,6 +94,53 @@ function shape(format, text, instruction, system) {
  * campos que no conocen, así que dejarla puesta sale gratis y permite rastrear
  * de qué página salió cada ejemplo cuando el modelo diga algo raro.
  */
+/**
+ * Tarjeta de dataset para Hugging Face (README.md con metadatos YAML). Un
+ * dataset sin tarjeta no dice de dónde salió ni qué se le quitó, y eso es justo
+ * lo que un equipo de ML necesita para confiar en él.
+ */
+export function datasetCard(stats, opts) {
+    const size = stats.records < 1000 ? "n<1K" : stats.records < 10000 ? "1K<n<10K" : stats.records < 100000 ? "10K<n<100K" : "100K<n<1M";
+    const splits = opts.splits ?? ["train"];
+    return [
+        "---",
+        `language: [${opts.language ?? "es"}]`,
+        `size_categories: [${size}]`,
+        "tags: [sirdas, pdf, local-processing]",
+        "configs:",
+        "  - config_name: default",
+        "    data_files:",
+        ...splits.map((sp) => `      - split: ${sp}
+        path: ${sp}.jsonl`),
+        "---",
+        "",
+        `# ${opts.name ?? "Dataset"}`,
+        "",
+        "Generado con [Sırdaş](https://sirdas.app) en la máquina de quien lo creó: los documentos originales no se subieron a ningún servicio.",
+        "",
+        "| | |",
+        "|---|---|",
+        `| Formato | \`${opts.format}\` |`,
+        `| Registros | ${stats.records} |`,
+        `| Documentos de origen | ${stats.documents} |`,
+        `| Tokens (estimados) | ${stats.tokens} (mediana ${stats.medianTokens}, máx. ${stats.maxTokens}) |`,
+        `| Anonimizado | ${opts.anonymized ? `sí: ${stats.redacted} datos personales sustituidos en ${stats.recordsWithPii} registros` : "no"} |`,
+        `| Deduplicado | ${opts.deduplicated ? "sí (MinHash)" : "no"} |`,
+        `| Particiones | ${splits.join(", ")}${splits.length > 1 ? " — repartidas por documento, nunca por trozo, para que no se filtren a evaluación" : ""} |`,
+        "",
+        "## Uso",
+        "",
+        "```python",
+        "from datasets import load_dataset",
+        'ds = load_dataset("json", data_files={' + splits.map((sp) => `"${sp}": "${sp}.jsonl"`).join(", ") + "})",
+        "```",
+        "",
+        "## Límites",
+        "",
+        "La anonimización es por reglas (identificaciones, NIT, correos, teléfonos, direcciones, nombres con etiqueta) y puede dejar pasar formatos poco comunes. Revisa una muestra antes de publicar.",
+        "",
+    ].join("\n");
+}
 export function toJsonl(records, withMeta = true) {
     return records
         .map((r) => JSON.stringify(withMeta ? { ...r.data, sirdas: r.meta } : r.data))

package/dist/extract.d.ts

@@ -0,0 +1,16 @@
+import type { DocType } from "./classify.js";
+export interface ExtractedField {
+    /** Nombre estable en snake_case, pensado para JSON y hojas de cálculo. */
+    name: string;
+    value: string;
+    /** Página (base 1) donde apareció, si el Markdown traía marcas de página. */
+    page: number | null;
+    /** El fragmento que casó la regla: la cita para que una persona lo verifique. */
+    evidence: string;
+    /** Dato de una persona: se sustituye si se pide anonimizar. */
+    personal: boolean;
+}
+/** Tipos para los que hay reglas: el resto devuelve lista vacía, no un error. */
+export declare const EXTRACTABLE_TYPES: DocType[];
+/** Extrae los campos de un tipo. Mejor con Markdown generado con `pageMarkers: true`, para citar la página. */
+export declare function extractFields(markdown: string, type: DocType): ExtractedField[];

package/dist/extract.js

@@ -0,0 +1,103 @@
+import { PAGE_MARKER } from "./markdown.js";
+const money = (v) => v.replace(/[\s$]/g, "");
+const digits = (v) => v.replace(/[^\dkK-]/g, "");
+const AMOUNT = String.raw `\$?\s*([\d]{1,3}(?:[.,\s]\d{3})*(?:[.,]\d{1,2})?)`;
+const DATE = String.raw `(\d{1,2}[/-]\d{1,2}[/-]\d{2,4}|\d{4}-\d{2}-\d{2}|\d{1,2}\s+de\s+[a-záéíóú]+\s+de\s+\d{4})`;
+const NIT = String.raw `(\d{3}\.?\d{3}\.?\d{3}\s*-?\s*\d)`;
+const RULES = {
+    factura: [
+        { name: "numero_factura", re: /factura[^\n]{0,40}?(?:n[oº°.]*|número|numero)\s*[:.]?\s*([A-Z]{0,6}-?\d{1,12})/i },
+        { name: "cufe", re: /\bcufe\s*[:.]?\s*([0-9a-f]{8,128})/i },
+        { name: "nit_emisor", re: new RegExp(String.raw `nit[^\n\d]{0,20}` + NIT, "i"), clean: digits },
+        { name: "fecha_emision", re: new RegExp(String.raw `fecha(?:\s+de)?\s*(?:emisi[oó]n|expedici[oó]n|factura)?\s*[:.]?\s*` + DATE, "i") },
+        { name: "fecha_vencimiento", re: new RegExp(String.raw `vencimiento\s*[:.]?\s*` + DATE, "i") },
+        { name: "subtotal", re: new RegExp(String.raw `subtotal\s*[:.]?\s*` + AMOUNT, "i"), clean: money },
+        { name: "iva", re: new RegExp(String.raw `\biva\b(?:\s*\d{1,2}\s*%)?\s*[:.]?\s*` + AMOUNT, "i"), clean: money },
+        // «Subtotal» también contiene «total»: se exige que no vaya pegado a otra palabra.
+        { name: "total", re: new RegExp(String.raw `(?<![a-záéíóú])total\s*(?:a\s+pagar|factura|general)?\s*[:.]?\s*` + AMOUNT, "i"), clean: money },
+        { name: "resolucion_dian", re: /resoluci[oó]n(?:\s+dian)?\s*(?:n[oº°.]*)?\s*[:.]?\s*(\d{8,20})/i },
+    ],
+    rut: [
+        { name: "nit", re: new RegExp(String.raw `(?:n[uú]mero\s+de\s+identificaci[oó]n\s+tributaria|\bnit\b)[^\n\d]{0,30}` + NIT, "i"), clean: digits },
+        { name: "razon_social", re: /raz[oó]n\s+social\s*[:.]?\s*([^\n]{3,80})/i },
+        { name: "direccion_seccional", re: /direcci[oó]n\s+seccional\s*[:.]?\s*([^\n]{3,60})/i },
+        { name: "actividad_principal", re: /actividad\s+principal\s*[:.]?\s*(\d{4})/i },
+    ],
+    cedula: [
+        { name: "numero_documento", re: /(?:n[uú]mero|c\.?\s?c\.?|c[eé]dula(?:\s+de\s+ciudadan[ií]a)?)\s*[:.]?\s*(\d{1,3}(?:\.\d{3}){1,3}|\d{6,10})\b/i, personal: true, clean: digits },
+        { name: "fecha_nacimiento", re: new RegExp(String.raw `fecha\s+de\s+nacimiento\s*[:.]?\s*` + DATE, "i"), personal: true },
+        { name: "fecha_expedicion", re: new RegExp(String.raw `fecha\s+(?:y\s+lugar\s+)?de\s+expedici[oó]n\s*[:.]?\s*` + DATE, "i") },
+    ],
+    historia_clinica: [
+        { name: "paciente", re: /[Pp]aciente\s*[:.]?\s*([A-ZÁÉÍÓÚÑ][a-záéíóúñ]+(?:[ \t]+[A-ZÁÉÍÓÚÑ][a-záéíóúñ]+){1,4})/, personal: true },
+        { name: "documento_paciente", re: /(?:c\.?\s?c\.?|documento|identificaci[oó]n)\s*[:.]?\s*(\d{1,3}(?:\.\d{3}){1,3}|\d{6,10})\b/i, personal: true, clean: digits },
+        { name: "fecha_atencion", re: new RegExp(String.raw `fecha(?:\s+de)?\s*(?:atenci[oó]n|ingreso|consulta)?\s*[:.]?\s*` + DATE, "i") },
+        { name: "motivo_consulta", re: /motivo\s+de\s+consulta\s*[:.]?\s*([^\n]{3,160})/i },
+        { name: "diagnostico_cie10", re: /\b([A-TV-Z]\d{2}(?:\.?\d{1,2})?)\b(?=[^\n]{0,80}(?:diagn|cie|principal|relacionado)|\s*[-–:]\s*[A-ZÁÉÍÓÚ])/g, all: true },
+    ],
+    extracto_bancario: [
+        { name: "numero_cuenta", re: /(?:n[uú]mero\s+de\s+)?cuenta\s*(?:n[oº°.]*)?\s*[:.]?\s*([*\dX]{4,}[\d-]*)/i, personal: true },
+        { name: "periodo", re: new RegExp(String.raw `(?:periodo|per[ií]odo)\s*[:.]?\s*` + DATE + String.raw `(?:\s*(?:al|a|-)\s*)` + DATE, "i") },
+        { name: "saldo_anterior", re: new RegExp(String.raw `saldo\s+anterior\s*[:.]?\s*` + AMOUNT, "i"), clean: money },
+        { name: "saldo_final", re: new RegExp(String.raw `saldo\s+(?:final|actual|disponible|total)\s*[:.]?\s*` + AMOUNT, "i"), clean: money },
+    ],
+    contrato: [
+        { name: "tipo_contrato", re: /contrato\s+de\s+([a-záéíóúñ ]{4,60}?)(?:\s+(?:entre|n[oº°.]|celebrado|suscrito)|[\n.,])/i },
+        { name: "valor", re: new RegExp(String.raw `valor(?:\s+(?:total|del\s+contrato))?\s*[:.]?\s*(?:de\s+)?` + AMOUNT, "i"), clean: money },
+        { name: "plazo", re: /(?:plazo|duraci[oó]n|t[eé]rmino)(?:\s+de\s+ejecuci[oó]n)?\s*[:.]?\s*(?:de\s+)?(\d{1,3}\s*\(?[a-z ]*\)?\s*(?:d[ií]as|meses|años))/i },
+        { name: "fecha_firma", re: new RegExp(String.raw `(?:firma|suscribe|a\s+los)[^\n]{0,40}?` + DATE, "i") },
+    ],
+    certificado: [
+        { name: "entidad", re: /^([A-ZÁÉÍÓÚÑ][A-ZÁÉÍÓÚÑ .&]{5,80})$/m },
+        { name: "fecha_expedicion", re: new RegExp(String.raw `(?:expedid[oa]|fecha)[^\n]{0,30}?` + DATE, "i") },
+    ],
+};
+/** Página de una posición: la última marca `<!-- page N -->` antes de ella. */
+function pageAt(markdown, index) {
+    let page = null;
+    const re = new RegExp(PAGE_MARKER.source.replace("^", "").replace("$", ""), "g");
+    for (const m of markdown.matchAll(re)) {
+        if ((m.index ?? 0) > index)
+            break;
+        page = Number(m[1]);
+    }
+    return page;
+}
+function evidenceAround(text, index, length) {
+    const start = text.lastIndexOf("\n", index) + 1;
+    const endNl = text.indexOf("\n", index + length);
+    return text
+        .slice(start, endNl === -1 ? undefined : endNl)
+        .trim()
+        .slice(0, 160);
+}
+/** Tipos para los que hay reglas: el resto devuelve lista vacía, no un error. */
+export const EXTRACTABLE_TYPES = Object.keys(RULES);
+/** Extrae los campos de un tipo. Mejor con Markdown generado con `pageMarkers: true`, para citar la página. */
+export function extractFields(markdown, type) {
+    const rules = RULES[type] ?? [];
+    const out = [];
+    for (const rule of rules) {
+        const re = rule.all ? new RegExp(rule.re.source, rule.re.flags.includes("g") ? rule.re.flags : rule.re.flags + "g") : rule.re;
+        const matches = rule.all ? [...markdown.matchAll(re)] : [markdown.match(re)].filter((m) => !!m);
+        const seen = new Set();
+        for (const m of matches) {
+            const raw = (m[1] ?? "").trim();
+            if (!raw)
+                continue;
+            const value = rule.clean ? rule.clean(raw) : raw.replace(/\s+/g, " ");
+            if (seen.has(value))
+                continue;
+            seen.add(value);
+            const index = m.index ?? 0;
+            out.push({
+                name: rule.name,
+                value,
+                page: pageAt(markdown, index),
+                evidence: evidenceAround(markdown, index, m[0].length),
+                personal: !!rule.personal,
+            });
+        }
+    }
+    return out;
+}

package/dist/formats.d.ts

@@ -0,0 +1,30 @@
+export type SourceFormat = "pdf" | "docx" | "xlsx" | "pptx" | "odt" | "ods" | "odp" | "epub" | "html" | "csv" | "tsv" | "md" | "txt" | "json" | "eml" | "rtf" | "image" | "unknown";
+export interface ConvertedDocument {
+    format: SourceFormat;
+    markdown: string;
+    /** Hojas, diapositivas o capítulos: la unidad natural de cada formato. */
+    parts: {
+        title: string;
+        markdown: string;
+    }[];
+    /** Tablas ya estructuradas (Excel, CSV, tablas de Word y HTML). */
+    tables: {
+        title: string;
+        rows: string[][];
+    }[];
+    warnings: string[];
+}
+/** Por contenido primero (la extensión miente a menudo), por nombre después. */
+export declare function detectFormat(bytes: Uint8Array, filename?: string): SourceFormat;
+export declare function rowsToMarkdown(rows: string[][]): string;
+export declare function htmlToMarkdown(html: string): {
+    markdown: string;
+    tables: string[][][];
+};
+/** CSV con comillas, separador autodetectado (coma, punto y coma o tabulador). */
+export declare function parseDelimited(text: string, delimiter?: string): string[][];
+/**
+ * Convierte cualquier formato soportado a Markdown. PDF e imágenes no pasan
+ * por aquí: necesitan PDF.js y OCR, y quien llama ya los tiene.
+ */
+export declare function convertToMarkdown(bytes: Uint8Array, filename?: string): ConvertedDocument;