@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/savoir/lecture.js

@@ -0,0 +1,406 @@
+/**
+ * Lecture d'une page web pour le savoir local : téléchargement prudent, puis extraction du texte.
+ *
+ * Les adresses viennent des résultats d'une recherche, donc d'internet : le serveur ne doit pas s'en servir pour joindre
+ * une machine de ton réseau ou ce PC lui-même (SSRF). D'où :
+ *  - http ou https, ports 80 et 443 seulement, pas d'identifiants dans l'adresse ;
+ *  - l'adresse IP est vérifiée au moment même de la connexion (résolution DNS faite par nous, refus de toute adresse privée,
+ *    de boucle locale, locale au lien, de partage d'opérateur, multicast ou réservée), y compris à chaque redirection ;
+ *  - 4 redirections au plus, 3 Mo au plus (décompressés), 12 s au plus, du HTML ou du texte seulement, aucun cookie.
+ * Le User-Agent nomme l'application, rien de plus.
+ */
+import dns from 'node:dns';
+import http from 'node:http';
+import https from 'node:https';
+import net from 'node:net';
+import zlib from 'node:zlib';
+import { VERSION } from '../config.js';
+export const MAX_PAGE_BYTES = 3 * 1024 * 1024;
+export const MAX_TEXT_CHARS = 60_000;
+export const PAGE_TIMEOUT_MS = 12_000;
+const MAX_REDIRECTS = 4;
+const USER_AGENT = `Mozilla/5.0 (compatible; Promethee/${VERSION}; lecture locale pour son utilisateur)`;
+export class ReadError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = 'ReadError';
+    }
+}
+// ------------------------------------------------------------------ Adresses
+const v4 = (ip) => ip.split('.').map(Number);
+/** Vrai pour une adresse joignable sur internet. Faux pour tout ce qui mène chez toi ou nulle part. */
+export function publicAddress(ip) {
+    if (net.isIPv4(ip)) {
+        const [a = 0, b = 0, c = 0] = v4(ip);
+        if (a === 0 || a === 10 || a === 127 || a >= 224)
+            return false;
+        if (a === 100 && b >= 64 && b <= 127)
+            return false;
+        if (a === 169 && b === 254)
+            return false;
+        if (a === 172 && b >= 16 && b <= 31)
+            return false;
+        if (a === 192 && b === 168)
+            return false;
+        if (a === 192 && b === 0 && (c === 0 || c === 2))
+            return false;
+        if (a === 198 && (b === 18 || b === 19))
+            return false;
+        if (a === 198 && b === 51 && c === 100)
+            return false;
+        if (a === 203 && b === 0 && c === 113)
+            return false;
+        return true;
+    }
+    if (net.isIPv6(ip)) {
+        const low = ip.toLowerCase();
+        const mapped = /^::ffff:(\d+\.\d+\.\d+\.\d+)$/.exec(low);
+        if (mapped?.[1])
+            return publicAddress(mapped[1]);
+        if (low === '::' || low === '::1')
+            return false;
+        const first = parseInt(low.split(':')[0] || '0', 16);
+        if ((first & 0xfe00) === 0xfc00)
+            return false; // fc00::/7, adresses locales uniques
+        if ((first & 0xffc0) === 0xfe80)
+            return false; // fe80::/10, locales au lien
+        if ((first & 0xff00) === 0xff00)
+            return false; // multicast
+        if (low.startsWith('64:ff9b:') || low.startsWith('100::') || low.startsWith('2001:db8:') || low.startsWith('::'))
+            return false;
+        return true;
+    }
+    return false;
+}
+/** Résolution DNS qui refuse toute adresse non publique : c'est elle que la connexion utilise, il n'y a pas de seconde résolution. */
+export function safeLookup(hostname, options, callback) {
+    dns.lookup(hostname, { ...options, all: true }, (err, addresses) => {
+        if (err)
+            return callback(err, '');
+        const list = addresses;
+        const bad = list.find((a) => !publicAddress(a.address));
+        if (bad || list.length === 0) {
+            const refused = new ReadError(`Adresse refusée : ${hostname} mène à une adresse privée ou réservée (${bad?.address ?? 'aucune'}).`);
+            refused.code = 'EPRIVATE';
+            return callback(refused, '');
+        }
+        if (options.all)
+            return callback(null, list);
+        const first = list[0];
+        callback(null, first?.address ?? '', first?.family);
+    });
+}
+/** Vérifie une adresse avant de la demander. Rend l'URL normalisée, ou lève une ReadError qui dit pourquoi. */
+export function checkUrl(raw) {
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        throw new ReadError('Adresse invalide.');
+    }
+    if (url.protocol !== 'http:' && url.protocol !== 'https:')
+        throw new ReadError(`Protocole refusé : ${url.protocol}`);
+    if (url.username || url.password)
+        throw new ReadError('Adresse avec identifiants refusée.');
+    if (url.port && url.port !== '80' && url.port !== '443')
+        throw new ReadError(`Port refusé : ${url.port}. Seuls 80 et 443 sont lus.`);
+    const host = url.hostname.replace(/^\[|\]$/g, '');
+    if (net.isIP(host) && !publicAddress(host))
+        throw new ReadError(`Adresse refusée : ${host} est privée ou réservée.`);
+    if (/^(localhost|.*\.localhost|.*\.local|.*\.internal|.*\.lan|.*\.home\.arpa)$/i.test(host))
+        throw new ReadError(`Nom refusé : ${host} désigne une machine locale.`);
+    url.hash = '';
+    return url;
+}
+export const getOnce = (url, signal) => {
+    return new Promise((resolve, reject) => {
+        const client = url.protocol === 'https:' ? https : http;
+        const req = client.request(url, {
+            method: 'GET',
+            lookup: safeLookup,
+            agent: false,
+            headers: { 'User-Agent': USER_AGENT, Accept: 'text/html,application/xhtml+xml,text/plain;q=0.9,*/*;q=0.1', 'Accept-Language': 'fr,en;q=0.8', 'Accept-Encoding': 'gzip, deflate, br' },
+            signal,
+            timeout: PAGE_TIMEOUT_MS,
+        }, (res) => {
+            const status = res.statusCode ?? 0;
+            if (status >= 300 && status < 400) {
+                res.resume();
+                return resolve({ status, headers: res.headers, body: Buffer.alloc(0) });
+            }
+            const encoding = String(res.headers['content-encoding'] ?? '').toLowerCase();
+            const stream = encoding === 'gzip' ? res.pipe(zlib.createGunzip()) : encoding === 'deflate' ? res.pipe(zlib.createInflate()) : encoding === 'br' ? res.pipe(zlib.createBrotliDecompress()) : res;
+            const chunks = [];
+            let size = 0;
+            stream.on('data', (chunk) => {
+                size += chunk.length;
+                if (size > MAX_PAGE_BYTES) {
+                    req.destroy();
+                    reject(new ReadError('Page trop lourde (plus de 3 Mo).'));
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            stream.on('end', () => resolve({ status, headers: res.headers, body: Buffer.concat(chunks) }));
+            stream.on('error', (err) => reject(err));
+        });
+        req.on('timeout', () => req.destroy(new ReadError(`La page n’a pas répondu en ${PAGE_TIMEOUT_MS / 1000} s.`)));
+        req.on('error', reject);
+        req.end();
+    });
+};
+/** Télécharge une page, redirections comprises, chaque étape vérifiée. get : la requête elle-même (remplacée dans les tests). */
+export const pageFetcher = (get = getOnce) => async (raw, signal) => {
+    let url = checkUrl(raw);
+    for (let hop = 0;; hop++) {
+        let res;
+        try {
+            res = await get(url, signal);
+        }
+        catch (err) {
+            if (err instanceof ReadError)
+                throw err;
+            if (err.code === 'EPRIVATE')
+                throw new ReadError(err.message);
+            if (signal.aborted)
+                throw new ReadError('Lecture interrompue.');
+            throw new ReadError(`Page injoignable : ${err.code ?? err.message}`);
+        }
+        if (res.status >= 300 && res.status < 400) {
+            const location = res.headers.location;
+            if (!location)
+                throw new ReadError(`Redirection ${res.status} sans adresse.`);
+            if (hop >= MAX_REDIRECTS)
+                throw new ReadError('Trop de redirections.');
+            url = checkUrl(new URL(location, url).toString());
+            continue;
+        }
+        if (res.status !== 200)
+            throw new ReadError(`Le site a répondu ${res.status}.`);
+        const contentType = String(res.headers['content-type'] ?? '').toLowerCase();
+        if (!/^(text\/html|application\/xhtml\+xml|text\/plain)\b/.test(contentType))
+            throw new ReadError(`Pas une page de texte (${contentType.split(';')[0] || 'type inconnu'}).`);
+        return { url: url.toString(), contentType, body: res.body };
+    }
+};
+export const fetchPage = pageFetcher();
+// ------------------------------------------------------------------ Extraction du texte
+/** Jeu de caractères : en-tête, puis balise meta, sinon UTF-8. */
+export function decodeBody(body, contentType) {
+    const head = body.subarray(0, 4096).toString('latin1');
+    const label = /charset=["']?([\w-]+)/i.exec(contentType)?.[1] ?? /<meta[^>]+charset=["']?([\w-]+)/i.exec(head)?.[1] ?? 'utf-8';
+    try {
+        return new TextDecoder(label.toLowerCase()).decode(body);
+    }
+    catch {
+        return new TextDecoder('utf-8').decode(body);
+    }
+}
+const ENTITIES = {
+    amp: '&', lt: '<', gt: '>', quot: '"', apos: "'", nbsp: ' ', ensp: ' ', emsp: ' ', thinsp: ' ', shy: '',
+    laquo: '«', raquo: '»', lsquo: '‘', rsquo: '’', ldquo: '“', rdquo: '”', sbquo: '‚', bdquo: '„', hellip: '…', ndash: '-', mdash: '-', middot: '·', bull: '•',
+    copy: '©', reg: '®', trade: '™', deg: '°', euro: '€', pound: '£', yen: '¥', cent: '¢', sect: '§', para: '¶', times: '×', divide: '÷', plusmn: '±', micro: 'µ',
+    agrave: 'à', aacute: 'á', acirc: 'â', atilde: 'ã', auml: 'ä', aring: 'å', aelig: 'æ', ccedil: 'ç', egrave: 'è', eacute: 'é', ecirc: 'ê', euml: 'ë',
+    igrave: 'ì', iacute: 'í', icirc: 'î', iuml: 'ï', ntilde: 'ñ', ograve: 'ò', oacute: 'ó', ocirc: 'ô', otilde: 'õ', ouml: 'ö', oslash: 'ø', oelig: 'œ',
+    ugrave: 'ù', uacute: 'ú', ucirc: 'û', uuml: 'ü', yacute: 'ý', yuml: 'ÿ', szlig: 'ß',
+    Agrave: 'À', Aacute: 'Á', Acirc: 'Â', Auml: 'Ä', Ccedil: 'Ç', Egrave: 'È', Eacute: 'É', Ecirc: 'Ê', Euml: 'Ë', Icirc: 'Î', Iuml: 'Ï', Ocirc: 'Ô', Ouml: 'Ö', OElig: 'Œ', Ugrave: 'Ù', Ucirc: 'Û', Uuml: 'Ü',
+};
+export function decodeEntities(s) {
+    return s.replace(/&(#x[0-9a-f]+|#\d+|[a-z][a-z0-9]*);/gi, (all, name) => {
+        if (name[0] === '#') {
+            const code = name[1] === 'x' || name[1] === 'X' ? parseInt(name.slice(2), 16) : parseInt(name.slice(1), 10);
+            return code > 0 && code < 0x110000 && !(code >= 0xd800 && code < 0xe000) ? String.fromCodePoint(code) : '';
+        }
+        return ENTITIES[name] ?? ENTITIES[name.toLowerCase()] ?? all;
+    });
+}
+/** Balises dont le contenu n'est jamais du texte de la page. */
+const DROP_WITH_CONTENT = /<(script|style|noscript|template|svg|math|iframe|object|canvas|select|textarea|button)\b[^>]*>[\s\S]*?<\/\1\s*>/gi;
+/** Conteneurs de navigation et d'habillage, sautés avec tout ce qu'ils contiennent. */
+const SKIP_TAGS = new Set(['nav', 'header', 'footer', 'aside', 'form', 'dialog', 'menu']);
+/**
+ * Un mot de classe ou d'id qui désigne l'habillage : navigation, pied de page, bandeau de cookies, partage, publicité… Le mot
+ * doit être entier ou entre tirets (« site-footer », « cookie_banner »), pour qu'un « shared-content » ou un « loads » restent.
+ * Pas « menu » : python.org l'emploie pour la liste de ses versions, et les vrais menus sont déjà sautés avec nav et header.
+ */
+const NOISE_TOKEN = /(^|[-_])(nav|navbar|navigation|breadcrumbs?|footer|sidebar|cookies?|consent|gdpr|share|sharing|social|newsletter|subscribe|advert|ads|promo|popup|modal|related)([-_]|$)/;
+const NOISE_ROLE = /\brole=["']?(navigation|banner|contentinfo|complementary|search)\b/i;
+/** Faut-il sauter ce bloc et tout son contenu ? Jamais pour article, main ou body : le texte principal y est. */
+function noisy(name, attrs, strict) {
+    if (SKIP_TAGS.has(name))
+        return true;
+    if (!strict || name === 'article' || name === 'main' || name === 'body')
+        return false;
+    if (NOISE_ROLE.test(attrs))
+        return true;
+    for (const m of attrs.matchAll(/\b(?:class|id)=["']([^"']*)["']/gi))
+        for (const token of (m[1] ?? '').toLowerCase().split(/\s+/))
+            if (NOISE_TOKEN.test(token))
+                return true;
+    return false;
+}
+const VOID = new Set(['area', 'base', 'br', 'col', 'embed', 'hr', 'img', 'input', 'link', 'meta', 'param', 'source', 'track', 'wbr']);
+const BLOCK = new Set(['p', 'div', 'section', 'article', 'main', 'li', 'ul', 'ol', 'dl', 'dt', 'dd', 'tr', 'table', 'thead', 'tbody', 'pre', 'blockquote', 'figure', 'figcaption', 'h1', 'h2', 'h3', 'h4', 'h5', 'h6', 'br', 'hr', 'td', 'th', 'caption', 'summary', 'details', 'address']);
+/** Le contenu principal : le plus long <article>, sinon <main>, sinon <body>, sinon tout. */
+function mainPart(html) {
+    const articles = [...html.matchAll(/<article\b[^>]*>([\s\S]*?)<\/article\s*>/gi)].map((m) => m[1] ?? '');
+    const longest = articles.sort((a, b) => b.length - a.length)[0];
+    if (longest && longest.length > 2000)
+        return longest;
+    const main = /<main\b[^>]*>([\s\S]*)<\/main\s*>/i.exec(html)?.[1];
+    if (main && main.length > 1000)
+        return main;
+    return /<body\b[^>]*>([\s\S]*)<\/body\s*>/i.exec(html)?.[1] ?? html;
+}
+/**
+ * Le texte lisible d'une page HTML : titres, paragraphes, listes, tableaux, sans menus ni scripts. Si le tri des blocs
+ * d'habillage laisse moins de 300 caractères (classes mal choisies, HTML mal fermé), on recommence sans lui.
+ */
+export function extractText(html) {
+    const strict = extractWith(html, true);
+    return strict.text.length >= 300 ? strict : extractWith(html, false);
+}
+function extractWith(html, strict) {
+    const title = decodeEntities(/<meta[^>]+property=["']og:title["'][^>]*content=["']([^"']+)/i.exec(html)?.[1] ?? /<title[^>]*>([\s\S]*?)<\/title\s*>/i.exec(html)?.[1] ?? '').replace(/\s+/g, ' ').trim();
+    const lang = /<html[^>]*\blang=["']?([a-zA-Z-]{2,10})/i.exec(html)?.[1]?.toLowerCase() ?? null;
+    const description = decodeEntities(/<meta[^>]+name=["']description["'][^>]*content=["']([^"']+)/i.exec(html)?.[1] ?? '').trim() || null;
+    const body = mainPart(html.replace(/<!--[\s\S]*?-->/g, ' ').replace(DROP_WITH_CONTENT, ' '));
+    const out = [];
+    const stack = [];
+    let skip = 0;
+    let last = 0;
+    const tag = /<\/?([a-zA-Z][\w:-]*)([^>]*)>/g;
+    const push = (text) => {
+        if (skip === 0 && text)
+            out.push(text);
+    };
+    for (let m = tag.exec(body); m; m = tag.exec(body)) {
+        push(body.slice(last, m.index));
+        last = m.index + m[0].length;
+        const name = (m[1] ?? '').toLowerCase();
+        const closing = m[0][1] === '/';
+        const attrs = m[2] ?? '';
+        if (VOID.has(name)) {
+            if (name === 'br' || name === 'hr')
+                push('\n');
+            continue;
+        }
+        if (!closing && !attrs.trimEnd().endsWith('/')) {
+            const skipped = noisy(name, attrs, strict);
+            stack.push(skipped ? `!${name}` : name);
+            if (skipped)
+                skip++;
+            if (BLOCK.has(name))
+                push(/^h[1-6]$/.test(name) ? '\n\n# ' : name === 'li' ? '\n- ' : '\n');
+        }
+        else if (closing) {
+            // On remonte jusqu'à la balise ouverte de même nom (HTML mal fermé toléré)
+            const at = stack.map((s) => s.replace(/^!/, '')).lastIndexOf(name);
+            if (at >= 0) {
+                for (const s of stack.splice(at))
+                    if (s.startsWith('!'))
+                        skip--;
+            }
+            if (BLOCK.has(name))
+                push(/^h[1-6]$/.test(name) ? '\n\n' : '\n');
+            if (name === 'td' || name === 'th')
+                push(' | ');
+        }
+    }
+    push(body.slice(last));
+    const lines = decodeEntities(out.join(''))
+        .replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f\u007f\u200b-\u200f\u2028\u2029\ufeff]/g, '')
+        .split('\n')
+        .map((l) => l.replace(/[ \t\u00a0]+/g, ' ').trim());
+    const kept = [];
+    for (const line of lines) {
+        if (!line || line === '-' || line === '#' || line === '|') {
+            if (kept.at(-1) !== '')
+                kept.push('');
+            continue;
+        }
+        if (line === kept.at(-1))
+            continue;
+        kept.push(line);
+    }
+    // Les suites de lignes très courtes (menus restés dans le corps) ne sont pas du texte : on les retire.
+    const paragraphs = kept.join('\n').split(/\n{2,}/).map((p) => p.trim());
+    const text = paragraphs
+        .filter((p) => {
+        const words = p.split(/\s+/).length;
+        return p.startsWith('# ') || words >= 6 || /[.!?:;]$/.test(p);
+    })
+        .join('\n\n')
+        .trim();
+    return { title, lang, description, text: text.slice(0, MAX_TEXT_CHARS) };
+}
+/** Un texte brut (text/plain) : lignes regroupées en paragraphes. */
+export function plainText(raw) {
+    const text = raw.replace(/\r\n?/g, '\n').replace(/[\u0000-\u0008\u000b\u000c\u000e-\u001f]/g, '').replace(/\n{3,}/g, '\n\n').trim();
+    return { title: text.split('\n')[0]?.slice(0, 120) ?? '', lang: null, description: null, text: text.slice(0, MAX_TEXT_CHARS) };
+}
+/** Lit une page et rend son texte. Moins de 300 caractères : la page n'a rien d'utile à retenir. */
+export async function readPage(url, signal, fetcher = fetchPage) {
+    const page = await fetcher(url, signal);
+    const raw = decodeBody(page.body, page.contentType);
+    const extracted = page.contentType.startsWith('text/plain') ? plainText(raw) : extractText(raw);
+    if (extracted.text.length < 300)
+        throw new ReadError('Presque aucun texte lisible : page chargée par JavaScript, page de consentement ou accès refusé.');
+    return { ...extracted, url: page.url };
+}
+/**
+ * Découpe un texte en passages d'environ 1 000 caractères, sans couper un paragraphe quand c'est possible. Un intertitre
+ * ouvre un nouveau passage, sauf si le passage en cours est encore court : les petites parties sont regroupées (une page
+ * faite de titres et de deux lignes donnerait sinon des passages presque vides, que le classement favorise). Un passage
+ * qui ne commence pas par un intertitre reprend celui qui était en vigueur, pour qu'il se comprenne seul.
+ */
+export function chunkText(text, size = 1000) {
+    const chunks = [];
+    const short = size * 0.4;
+    let heading = '';
+    let lead = '';
+    let current = '';
+    const flush = () => {
+        const body = current.trim();
+        if (body)
+            chunks.push(lead && !body.startsWith('# ') ? `${lead}\n${body}` : body);
+        current = '';
+    };
+    const add = (para) => {
+        if (!current)
+            lead = heading;
+        current += `${para}\n\n`;
+    };
+    for (const para of text.split(/\n{2,}/)) {
+        if (para.startsWith('# ')) {
+            if (current.length >= short)
+                flush();
+            heading = para.slice(0, 160);
+            add(heading);
+            continue;
+        }
+        if (para.length > size * 1.5) {
+            if (current.length >= short)
+                flush();
+            // Paragraphe très long : coupé aux fins de phrase
+            let piece = '';
+            for (const sentence of para.split(/(?<=[.!?])\s+/)) {
+                if ((current + piece + sentence).length > size && piece) {
+                    add(piece.trim());
+                    flush();
+                    piece = '';
+                }
+                piece += `${sentence} `;
+            }
+            if (piece.trim())
+                add(piece.trim());
+            continue;
+        }
+        if ((current + para).length > size && current.length >= short)
+            flush();
+        add(para);
+    }
+    flush();
+    return chunks.map((c) => c.slice(0, size * 2));
+}

package/lib/server/savoir/memoire.js

@@ -0,0 +1,115 @@
+import { queryTerms } from './base.js';
+export const READ_PAGES = 3;
+export const MAX_EXTRACTS = 6;
+export const EXTRACT_CHARS = 1200;
+export const EXTRACTS_TOTAL = 6000;
+/** Temps laissé à la lecture des pages, toutes en même temps, avant de répondre avec ce qui est arrivé. */
+export const READ_BUDGET_MS = 15_000;
+/** Sites qui ne montrent leur texte qu'avec JavaScript ou derrière un compte : pas la peine de les télécharger. */
+const UNREADABLE_HOST = /(^|\.)(youtube\.com|youtu\.be|x\.com|twitter\.com|facebook\.com|instagram\.com|tiktok\.com|linkedin\.com)$/i;
+const NOT_TEXT = /\.(pdf|docx?|xlsx?|pptx?|odt|zip|rar|7z|exe|msi|mp3|mp4|avi|mkv|jpe?g|png|gif|webp)$/i;
+/** Les premières sources qui ont une chance d'être lisibles : pages web, hors vidéos, réseaux sociaux et fichiers. */
+export function pagesToRead(sources, count = READ_PAGES) {
+    const picked = [];
+    for (const s of sources) {
+        let url;
+        try {
+            url = new URL(s.url);
+        }
+        catch {
+            continue;
+        }
+        if (url.protocol !== 'https:' && url.protocol !== 'http:')
+            continue;
+        if (UNREADABLE_HOST.test(url.hostname) || NOT_TEXT.test(url.pathname))
+            continue;
+        if (picked.some((p) => p.url === s.url))
+            continue;
+        picked.push(s);
+        if (picked.length >= count)
+            break;
+    }
+    return picked;
+}
+/** Coupe un passage à max caractères, à la fin d'une phrase ou d'un mot. */
+export function cutPassage(text, max = EXTRACT_CHARS) {
+    const clean = text.trim();
+    if (clean.length <= max)
+        return clean;
+    const head = clean.slice(0, max);
+    const sentence = Math.max(head.lastIndexOf('. '), head.lastIndexOf('.\n'), head.lastIndexOf('? '), head.lastIndexOf('! '));
+    if (sentence > max * 0.6)
+        return head.slice(0, sentence + 1);
+    const space = head.lastIndexOf(' ');
+    return `${head.slice(0, space > max * 0.6 ? space : max)} […]`;
+}
+/** Prend les passages dans l'ordre de priorité, dans le budget, puis les range par numéro et par position dans la page. */
+function fill(candidates) {
+    const kept = [];
+    let total = 0;
+    for (const c of candidates) {
+        if (kept.length >= MAX_EXTRACTS)
+            break;
+        if (kept.some((k) => k.pageId === c.hit.pageId && k.ord === c.hit.ord))
+            continue;
+        const room = Math.min(EXTRACT_CHARS, EXTRACTS_TOTAL - total);
+        if (room < 300)
+            break;
+        const text = cutPassage(c.hit.text, room);
+        total += text.length;
+        kept.push({ n: c.n, pageId: c.hit.pageId, url: c.hit.url, title: c.hit.title, host: c.hit.host, learnedAt: c.hit.learnedAt, fresh: c.fresh, text, ord: c.hit.ord });
+    }
+    return kept.sort((a, b) => a.n - b.n || a.ord - b.ord).map(({ ord: _ord, ...extract }) => extract);
+}
+/**
+ * Les passages donnés au modèle après une recherche. question : la demande et la requête, pour choisir dans les pages lues ;
+ * query : la requête seule, plus nette, pour chercher dans le savoir plus ancien ; next : premier numéro libre après les sources.
+ */
+export function searchExtracts(savoir, read, question, query, next) {
+    const best = [];
+    const openings = [];
+    const second = [];
+    const minFound = Math.min(2, queryTerms(question).length);
+    for (const page of read) {
+        const hits = savoir.search(question, { only: [page.pageId], perPage: 2, limit: 2, minFound });
+        // Le début de la page compte toujours : le moteur l'a classée sur son titre et son haut de page, où la réponse se
+        // trouve souvent (la liste des versions de python.org, le chapeau d'un article), même sans les mots de la question.
+        const [start] = savoir.opening(page.pageId, 1);
+        const [first, next2] = hits;
+        if (first)
+            best.push({ hit: first, n: page.n, fresh: page.fresh });
+        if (start && start.ord !== first?.ord)
+            (first ? openings : best).push({ hit: start, n: page.n, fresh: page.fresh });
+        if (next2)
+            second.push({ hit: next2, n: page.n, fresh: page.fresh });
+    }
+    const terms = queryTerms(query);
+    const older = [];
+    if (terms.length > 0) {
+        const hits = savoir.search(query, { except: read.map((p) => p.pageId), minRatio: 0.5, minFound: Math.min(2, terms.length), perPage: 1, limit: 2 });
+        for (const hit of hits)
+            older.push({ hit, n: next++, fresh: false });
+    }
+    const extracts = fill([...best, ...older, ...openings, ...second]);
+    savoir.used(extracts.map((e) => e.pageId));
+    return extracts;
+}
+/**
+ * Rappel sans recherche web : des passages seulement s'ils couvrent au moins 60 % des mots de la question, et deux mots
+ * au moins quand elle en a deux. Numérotés de 1 à n, une page par numéro.
+ */
+export function recallExtracts(savoir, question) {
+    const terms = queryTerms(question);
+    if (terms.length === 0)
+        return [];
+    const hits = savoir.search(question, { minRatio: 0.6, minFound: Math.min(2, terms.length), perPage: 2, limit: 4 });
+    const numbers = new Map();
+    const candidates = hits.map((hit) => {
+        if (!numbers.has(hit.pageId))
+            numbers.set(hit.pageId, numbers.size + 1);
+        return { hit, n: numbers.get(hit.pageId) ?? 1, fresh: false };
+    });
+    const extracts = fill(candidates);
+    savoir.used(extracts.map((e) => e.pageId));
+    return extracts;
+}