@nosserb/prmt 0.0.0-stage → 2.0.0

package/lib/server/savoir/base.js

@@ -0,0 +1,284 @@
+/**
+ * Le savoir local : les pages lues après une recherche, découpées en passages, dans une base SQLite (data/savoir.db).
+ *
+ * Le modèle ne change pas : il relit ces passages avant de répondre. La recherche est plein texte (FTS5, accents ignorés,
+ * classement BM25), avec un radical grossier (« vulnérabilités » trouve « vulnerability ») et une mesure de couverture : un
+ * passage n'est relu hors recherche web que s'il contient l'essentiel des mots de la question.
+ *
+ * Taille bornée : au-delà de 15 millions de caractères, les pages les moins récemment utilisées partent.
+ */
+import { createHash } from 'node:crypto';
+import fs from 'node:fs';
+import path from 'node:path';
+import { DatabaseSync } from 'node:sqlite';
+import { chunkText } from './lecture.js';
+export const MAX_CHARS = 15_000_000;
+/** Une page lue il y a moins de 7 jours n'est pas relue sur le web. */
+export const FRESH_DAYS = 7;
+const STOP = new Set(('les des une est pas pour que qui dans sur avec par plus sont aux ces ses son sa mon ma mes ton ta tes leur leurs nous vous ils elles elle lui ' +
+    'cette cet tout tous toute toutes comme mais donc car aussi bien fait faire peut peux veux quoi quel quelle quels quelles comment pourquoi ' +
+    'quand combien est-ce cela ceci etre avoir dois doit faut entre sans sous chez vers apres avant depuis encore deja tres trop alors ' +
+    'explique expliquer explication donne donner dire dis montre montrer parle parler resume resumer sais savoir connais connait ' +
+    'the and for with that this from are was were has have had not but you your what which who how why when where can does did its into ' +
+    'about will would should could there their them they then than also more most some any all our out use using').split(' '));
+const plain = (s) => s.normalize('NFD').replace(/[\u0300-\u036f]/g, '').toLowerCase();
+/** Les mots qui comptent dans une question : sans accents, sans mots vides, 3 lettres au moins ou un chiffre. */
+export function queryTerms(text) {
+    const terms = [];
+    for (const w of plain(text).split(/[^\p{L}\p{N}]+/u)) {
+        if (!w || STOP.has(w))
+            continue;
+        if (w.length < 3 && !/\d/.test(w))
+            continue;
+        if (!terms.includes(w))
+            terms.push(w);
+    }
+    return terms.slice(0, 16);
+}
+/** Radical grossier : les mots longs perdent leur fin (pluriel, accord, -ité / -ity), pour une recherche par préfixe. */
+export const stem = (term) => (term.length > 5 && !/\d/.test(term) ? term.slice(0, Math.max(5, term.length - 2)) : term);
+/**
+ * Équivalents anglais des mots les plus courants des questions : beaucoup de pages techniques sont en anglais, et
+ * « dernière version » ne trouverait jamais « latest release ». Une recherche par le sens (modèle d'embedding) ferait
+ * mieux, sans liste. Les mots dont le radical suffit (sécurité, vulnérabilité) n'y sont pas.
+ */
+const ALSO = {
+    dernier: ['latest', 'newest'],
+    derniere: ['latest', 'newest'],
+    derniers: ['latest'],
+    dernieres: ['latest'],
+    nouveaute: ['new', 'changelog'],
+    nouveautes: ['new', 'changelog'],
+    nouveau: ['new'],
+    nouvelle: ['new'],
+    nouvelles: ['new'],
+    neuf: ['new'],
+    version: ['release'],
+    versions: ['releases'],
+    sortie: ['release', 'released'],
+    sorti: ['released'],
+    faille: ['vulnerability', 'flaw'],
+    failles: ['vulnerabilities', 'flaws'],
+    correctif: ['patch', 'fix'],
+    correctifs: ['patches', 'fixes'],
+    telecharger: ['download'],
+    telechargement: ['download'],
+    reseau: ['network'],
+    logiciel: ['software'],
+    navigateur: ['browser'],
+    annonce: ['announcement', 'announced'],
+};
+/** Un mot de la question et ses équivalents : l'un d'eux suffit. */
+export const variants = (term) => [term, ...(ALSO[term] ?? [])];
+/** Requête FTS5 : chaque mot entre guillemets (aucun opérateur ne passe), en préfixe pour les mots longs, reliés par OR. */
+export function ftsQuery(terms) {
+    return terms
+        .flatMap(variants)
+        .map((t) => (stem(t) !== t ? `"${stem(t)}"*` : `"${t}"`))
+        .join(' OR ');
+}
+/** Part des mots de la question présents dans un passage (par radical). */
+export function coverage(terms, text) {
+    if (terms.length === 0)
+        return { found: 0, ratio: 0 };
+    const words = new Set(plain(text).split(/[^\p{L}\p{N}]+/u));
+    const all = [...words];
+    let found = 0;
+    const has = (t) => {
+        const s = stem(t);
+        return words.has(t) || (s !== t && all.some((w) => w.startsWith(s)));
+    };
+    for (const t of terms)
+        if (variants(t).some(has))
+            found++;
+    return { found, ratio: found / terms.length };
+}
+const toPage = (r) => ({ id: r.id, url: r.url, host: r.host, title: r.title, learnedAt: r.learned_at, usedAt: r.used_at, uses: r.uses, chars: r.chars, query: r.query });
+export class Savoir {
+    db;
+    file;
+    now;
+    maxChars;
+    /** file null : base en mémoire (tests). */
+    constructor(file, options = {}) {
+        this.file = file;
+        this.now = options.now ?? Date.now;
+        this.maxChars = options.maxChars ?? MAX_CHARS;
+        if (file)
+            fs.mkdirSync(path.dirname(file), { recursive: true });
+        this.db = new DatabaseSync(file ?? ':memory:');
+        this.db.exec(`
+      PRAGMA journal_mode = WAL;
+      PRAGMA foreign_keys = ON;
+      CREATE TABLE IF NOT EXISTS pages (
+        id TEXT PRIMARY KEY,
+        url TEXT NOT NULL UNIQUE,
+        host TEXT NOT NULL,
+        title TEXT NOT NULL,
+        lang TEXT,
+        learned_at TEXT NOT NULL,
+        used_at TEXT,
+        uses INTEGER NOT NULL DEFAULT 0,
+        chars INTEGER NOT NULL,
+        query TEXT,
+        text TEXT NOT NULL
+      );
+      CREATE VIRTUAL TABLE IF NOT EXISTS passages USING fts5(text, title, page_id UNINDEXED, ord UNINDEXED, tokenize = 'unicode61 remove_diacritics 2');
+    `);
+    }
+    close() {
+        this.db.close();
+    }
+    iso() {
+        return new Date(this.now()).toISOString();
+    }
+    /** La page déjà retenue pour cette adresse, si elle a moins de 7 jours. */
+    fresh(url) {
+        const row = this.db.prepare('SELECT id, url, host, title, learned_at, used_at, uses, chars, query FROM pages WHERE url = ?').get(url);
+        if (!row)
+            return null;
+        return this.now() - Date.parse(row.learned_at) < FRESH_DAYS * 86_400_000 ? toPage(row) : null;
+    }
+    /** Retient une page : son texte entier et ses passages. Une page déjà connue est remplacée. */
+    learn(input) {
+        const url = input.url;
+        const host = new URL(url).hostname.replace(/^www\./, '');
+        const id = createHash('sha256').update(url).digest('hex').slice(0, 16);
+        const title = (input.title || host).slice(0, 300);
+        const chunks = chunkText(input.text);
+        this.db.exec('BEGIN');
+        try {
+            this.db.prepare('DELETE FROM passages WHERE page_id = ?').run(id);
+            this.db.prepare('DELETE FROM pages WHERE id = ?').run(id);
+            this.db
+                .prepare('INSERT INTO pages (id, url, host, title, lang, learned_at, used_at, uses, chars, query, text) VALUES (?, ?, ?, ?, ?, ?, NULL, 0, ?, ?, ?)')
+                .run(id, url, host, title, input.lang, this.iso(), input.text.length, input.query, input.text);
+            const insert = this.db.prepare('INSERT INTO passages (text, title, page_id, ord) VALUES (?, ?, ?, ?)');
+            chunks.forEach((text, ord) => insert.run(text, title, id, ord));
+            this.db.exec('COMMIT');
+        }
+        catch (err) {
+            this.db.exec('ROLLBACK');
+            throw err;
+        }
+        this.evict();
+        return this.page(id);
+    }
+    page(id) {
+        const row = this.db.prepare('SELECT id, url, host, title, learned_at, used_at, uses, chars, query FROM pages WHERE id = ?').get(id);
+        return row ? toPage(row) : null;
+    }
+    /** Une page et son texte retenu. */
+    get(id) {
+        const row = this.db.prepare('SELECT id, url, host, title, learned_at, used_at, uses, chars, query, text FROM pages WHERE id = ?').get(id);
+        return row ? { page: toPage(row), text: row.text } : null;
+    }
+    /**
+     * Les passages les plus pertinents pour une question. only : seulement ces pages ; except : sauf celles-là.
+     * minRatio et minFound filtrent par couverture (0 : tout ce que FTS5 trouve).
+     */
+    search(question, options = {}) {
+        const terms = queryTerms(question);
+        if (terms.length === 0)
+            return [];
+        const rows = this.db
+            .prepare(`SELECT p.id AS page_id, p.url, p.title, p.host, p.learned_at, s.ord, s.text, bm25(passages, 1.0, 0.5) AS score
+         FROM passages s JOIN pages p ON p.id = s.page_id
+         WHERE passages MATCH ? ORDER BY score LIMIT 200`)
+            .all(ftsQuery(terms));
+        const hits = [];
+        const perPage = new Map();
+        for (const r of rows) {
+            if (options.only && !options.only.includes(r.page_id))
+                continue;
+            if (options.except?.includes(r.page_id))
+                continue;
+            const { found, ratio } = coverage(terms, `${r.title} ${r.text}`);
+            if (ratio < (options.minRatio ?? 0) || found < (options.minFound ?? 0))
+                continue;
+            const n = perPage.get(r.page_id) ?? 0;
+            if (n >= (options.perPage ?? 2))
+                continue;
+            perPage.set(r.page_id, n + 1);
+            hits.push({ pageId: r.page_id, url: r.url, title: r.title, host: r.host, learnedAt: r.learned_at, ord: Number(r.ord), text: r.text, score: r.score, found, ratio });
+            if (hits.length >= (options.limit ?? 6))
+                break;
+        }
+        return hits;
+    }
+    /** Les premiers passages d'une page : son début, quand aucun mot de la question n'y figure. */
+    opening(pageId, count = 1) {
+        const page = this.page(pageId);
+        if (!page)
+            return [];
+        const rows = this.db.prepare('SELECT ord, text FROM passages WHERE page_id = ? ORDER BY CAST(ord AS INTEGER) LIMIT ?').all(pageId, count);
+        return rows.map((r) => ({ pageId, url: page.url, title: page.title, host: page.host, learnedAt: page.learnedAt, ord: Number(r.ord), text: r.text, score: 0, found: 0, ratio: 0 }));
+    }
+    /** Note que des passages de ces pages ont été donnés au modèle. */
+    used(pageIds) {
+        const at = this.iso();
+        const stmt = this.db.prepare('UPDATE pages SET uses = uses + 1, used_at = ? WHERE id = ?');
+        for (const id of new Set(pageIds))
+            stmt.run(at, id);
+    }
+    list(options = {}) {
+        const limit = Math.min(Math.max(options.limit ?? 100, 1), 500);
+        const q = options.q?.trim();
+        let rows;
+        if (q) {
+            const like = `%${q.replace(/[\\%_]/g, (c) => `\\${c}`)}%`;
+            const terms = queryTerms(q);
+            const byText = terms.length
+                ? this.db.prepare('SELECT DISTINCT page_id FROM passages WHERE passages MATCH ?').all(ftsQuery(terms)).map((r) => r.page_id)
+                : [];
+            rows = this.db
+                .prepare(`SELECT id, url, host, title, learned_at, used_at, uses, chars, query FROM pages
+             WHERE title LIKE ? ESCAPE '\\' OR url LIKE ? ESCAPE '\\' OR id IN (SELECT value FROM json_each(?))
+             ORDER BY COALESCE(used_at, learned_at) DESC LIMIT ?`)
+                .all(like, like, JSON.stringify(byText), limit);
+        }
+        else {
+            rows = this.db.prepare('SELECT id, url, host, title, learned_at, used_at, uses, chars, query FROM pages ORDER BY COALESCE(used_at, learned_at) DESC LIMIT ?').all(limit);
+        }
+        const totals = this.db.prepare('SELECT COUNT(*) AS n, COALESCE(SUM(chars), 0) AS c FROM pages').get();
+        return { pages: rows.map(toPage), total: Number(totals.n), chars: Number(totals.c), bytes: this.bytes() };
+    }
+    get size() {
+        return Number(this.db.prepare('SELECT COUNT(*) AS n FROM pages').get().n);
+    }
+    bytes() {
+        if (!this.file)
+            return 0;
+        let total = 0;
+        for (const suffix of ['', '-wal'])
+            total += fs.statSync(this.file + suffix, { throwIfNoEntry: false })?.size ?? 0;
+        return total;
+    }
+    forget(id) {
+        const page = this.page(id);
+        if (!page)
+            return null;
+        this.db.prepare('DELETE FROM passages WHERE page_id = ?').run(id);
+        this.db.prepare('DELETE FROM pages WHERE id = ?').run(id);
+        return page;
+    }
+    forgetAll() {
+        const n = this.size;
+        this.db.exec('DELETE FROM passages; DELETE FROM pages;');
+        this.db.exec('VACUUM');
+        return n;
+    }
+    /** Au-delà de MAX_CHARS, les pages les moins récemment utilisées partent, jusqu'à 90 % du plafond. */
+    evict(max = this.maxChars) {
+        let total = Number(this.db.prepare('SELECT COALESCE(SUM(chars), 0) AS c FROM pages').get().c);
+        if (total <= max)
+            return;
+        const old = this.db.prepare('SELECT id, chars FROM pages ORDER BY COALESCE(used_at, learned_at) ASC').all();
+        for (const p of old) {
+            if (total <= max * 0.9)
+                break;
+            this.forget(p.id);
+            total -= Number(p.chars);
+        }
+    }
+}