@cachly-dev/mcp-server 0.10.129 → 0.10.131

package/dist/src/eingaenge-nachruesten.js

@@ -1,290 +1 @@
-/**
- * Rüstet den vorhandenen Lektionsbestand mit Eingängen und Namensvektoren nach.
- *
- * ── Warum es dieses Werkzeug gibt ───────────────────────────────────────────
- *
- * Seit dem 20.08.2026 schreibt `learn_from_attempts` die Fehlertext-Eingänge
- * beim Speichern mit. Die Lektionen, die vorher entstanden sind, haben keine —
- * und ohne Nachrüstung wirkt die Verbesserung nur für alles, was ab heute
- * gelernt wird. Bei 501 vorhandenen und wenigen neuen Lektionen je Woche wäre
- * das praktisch keine Wirkung.
- *
- * ── Was es kostet ──────────────────────────────────────────────────────────
- *
- * Rund 1,3 Einbettungen je Lektion (nicht jede trägt einen Fehlertext).
- * Gemessen am 20.08.: 1440 Einbettungen in 406 s mit Admin-Schlüssel, das sind
- * 3,5 je Sekunde. Für 501 Lektionen also wenige Minuten.
- *
- * OHNE Admin-Schlüssel greift die Drosselung von 60 Anfragen je Minute
- * (api/cmd/server/routes.go). Ein paralleler Lauf hat am 19.08. 563 mal
- * HTTP 429 erzeugt, eine Wachhund-Warnung mit unserer eigenen Adresse
- * ausgelöst und eine automatische Hochskalierung angestoßen. Deshalb die
- * Notbremse.
- *
- * ── Was es NICHT tut ───────────────────────────────────────────────────────
- *
- * Es rührt die Lektionen selbst nicht an und schreibt keine Vektoren. Fällt es
- * mittendrin aus, ist der Bestand in demselben Zustand wie vorher, nur mit
- * weniger Eingängen — ein zweiter Lauf holt den Rest.
- *
- * Aufruf:
- *   REDIS_URL=... CACHLY_JWT=... CACHLY_ADMIN_KEY=... \
- *     npx tsx src/eingaenge-nachruesten.ts [--probe 20] [--parallel 6]
- *   npx tsx src/eingaenge-nachruesten.ts --selbstprobe
- */
-import { Redis } from 'ioredis';
-import { schreibeEingaenge, fehlertexteAus, eingangsText, EINGANG_PRAEFIX } from './eingaenge.js';
-import { NAME_VEKTOR_PRAEFIX, VEKTOR_PRAEFIX, packe, textFuerNamensVektor, textFuerVektor, } from './bedeutung.js';
-const LEKTION_PRAEFIX = 'cachly:lesson:best:';
-/** Zählt die 429er. Bei zehn ist Schluss — lieber abgebrochen als ein Vorfall. */
-class Notbremse {
-    grenze;
-    zaehler = 0;
-    constructor(grenze = 10) {
-        this.grenze = grenze;
-    }
-    melde429() { this.zaehler++; }
-    get gezogen() { return this.zaehler >= this.grenze; }
-    get stand() { return this.zaehler; }
-}
-/**
- * Wie viele Lektionen überhaupt einen Eingang bekommen könnten.
- *
- * Wird VOR dem ersten Netzaufruf gerechnet und gemeldet: wer die Zahl vorher
- * kennt, merkt sofort, wenn am Ende viel weniger herauskommt.
- */
-export function wieVieleTragen(lektionen) {
-    return lektionen.filter((l) => fehlertexteAus(eingangsText(l)).length > 0).length;
-}
-function selbstprobe() {
-    const proben = [];
-    const p = (was, ok) => { proben.push([was, ok]); };
-    const mit = { what_worked: 'Der Worker meldete "No space left on device".' };
-    const ohne = { what_worked: 'Wir haben die Reihenfolge der Schritte getauscht.' };
-    p('zählt nur Lektionen mit Fehlertext', wieVieleTragen([mit, ohne, mit]) === 2);
-    p('leerer Bestand ergibt null', wieVieleTragen([]) === 0);
-    const b = new Notbremse(3);
-    b.melde429();
-    b.melde429();
-    p('zwei von drei reichen nicht', !b.gezogen);
-    b.melde429();
-    p('drei ziehen die Bremse', b.gezogen);
-    let rot = 0;
-    for (const [was, ok] of proben) {
-        console.log(`${ok ? 'ok  ' : 'ROT '} ${was}`);
-        if (!ok)
-            rot++;
-    }
-    console.log(rot === 0 ? 'Selbstprobe bestanden.' : `Selbstprobe ROT: ${rot} von ${proben.length}.`);
-    process.exit(rot === 0 ? 0 : 1);
-}
-async function main() {
-    const argv = process.argv.slice(2);
-    const flag = (n) => {
-        const i = argv.indexOf(`--${n}`);
-        return i !== -1 ? argv[i + 1] : undefined;
-    };
-    const url = process.env.CACHLY_REDIS_URL ?? process.env.REDIS_URL;
-    const API = process.env.CACHLY_API_URL ?? 'https://api.cachly.dev';
-    const JWT = process.env.CACHLY_JWT ?? '';
-    const ADMIN = process.env.CACHLY_ADMIN_KEY ?? '';
-    if (!url) {
-        console.error('NICHT GELAUFEN: CACHLY_REDIS_URL oder REDIS_URL fehlt.');
-        process.exit(2);
-    }
-    if (!JWT) {
-        console.error('NICHT GELAUFEN: CACHLY_JWT fehlt.');
-        process.exit(2);
-    }
-    const probe = Number(flag('probe') ?? '0');
-    const parallel = Number(flag('parallel') ?? (ADMIN ? '6' : '2'));
-    const bremse = new Notbremse(10);
-    const einbetten = async (text) => {
-        for (let versuch = 0; versuch < 4; versuch++) {
-            if (bremse.gezogen)
-                return null;
-            try {
-                const kopf = { 'Content-Type': 'application/json', Authorization: `Bearer ${JWT}` };
-                if (ADMIN)
-                    kopf['X-Admin-Key'] = ADMIN;
-                const r = await fetch(`${API}/api/v1/embed`, {
-                    method: 'POST', headers: kopf,
-                    body: JSON.stringify({ text: text.slice(0, 2000) }),
-                    signal: AbortSignal.timeout(60_000),
-                });
-                if (r.status === 429) {
-                    bremse.melde429();
-                    await new Promise((f) => setTimeout(f, 2000 * (versuch + 1)));
-                    continue;
-                }
-                if (!r.ok)
-                    return null;
-                const j = await r.json();
-                return j.embedding ?? j.data?.[0]?.embedding ?? null;
-            }
-            catch {
-                await new Promise((f) => setTimeout(f, 800 * (versuch + 1)));
-            }
-        }
-        return null;
-    };
-    const redis = new Redis(url, { maxRetriesPerRequest: 2, connectTimeout: 8000 });
-    try {
-        const schluessel = [];
-        let cursor = '0';
-        do {
-            const [next, gefunden] = await redis.scan(cursor, 'MATCH', `${LEKTION_PRAEFIX}*`, 'COUNT', 500);
-            cursor = next;
-            schluessel.push(...gefunden);
-        } while (cursor !== '0');
-        if (schluessel.length === 0) {
-            console.error(`NICHT GELAUFEN: keine Lektionen unter ${LEKTION_PRAEFIX}* — falsche Instanz?`);
-            process.exit(3);
-        }
-        const lektionen = [];
-        for (let i = 0; i < schluessel.length; i += 100) {
-            const block = schluessel.slice(i, i + 100);
-            const werte = await redis.mget(...block);
-            for (const [j, roh] of werte.entries()) {
-                if (!roh)
-                    continue;
-                try {
-                    const o = JSON.parse(roh);
-                    const topic = typeof o.topic === 'string' && o.topic ? o.topic : block[j].slice(LEKTION_PRAEFIX.length);
-                    if (topic)
-                        lektionen.push({ topic, inhalt: o });
-                }
-                catch { /* eine kaputte Zeile ist ein Thema fuer doctor */ }
-            }
-        }
-        // Was schon da ist, wird übersprungen — ein zweiter Lauf ist billig.
-        const schonDa = async (praefix) => {
-            const menge = new Set();
-            let c = '0';
-            do {
-                const [next, gefunden] = await redis.scan(c, 'MATCH', `${praefix}*`, 'COUNT', 500);
-                c = next;
-                for (const k of gefunden)
-                    menge.add(k.slice(praefix.length));
-            } while (c !== '0');
-            return menge;
-        };
-        let fertigNamen = 0;
-        const vorhanden = await schonDa(EINGANG_PRAEFIX);
-        const namenDa = await schonDa(NAME_VEKTOR_PRAEFIX);
-        const volltextDa = await schonDa(VEKTOR_PRAEFIX);
-        // ── Volltextvektoren ─────────────────────────────────────────────────────
-        //
-        // Gemessen am 20.08.2026 gegen die Produktion: `cachly:lesson:vec:*` war
-        // LEER — bei 506 Lektionen kein einziger Vektor. Damit lief der
-        // Bedeutungsabgleich dort nie: `vektorbestand.groesse === 0` steigt in
-        // brain.ts sofort aus und faellt auf den reinen Wortabgleich zurueck.
-        //
-        // Das ist die Grundlage von allem anderen. Ohne diese Vektoren nuetzen
-        // weder Namensvektoren noch Eingaenge etwas.
-        const ohneVolltext = lektionen.filter((l) => !volltextDa.has(l.topic));
-        console.log(`${volltextDa.size} Lektionen haben einen Volltextvektor, ${ohneVolltext.length} fehlen.`);
-        if (ohneVolltext.length > 0) {
-            let n = 0;
-            let fertigVoll = 0;
-            let naechsterVoll = 0;
-            const vollArbeiter = Array.from({ length: parallel }, async () => {
-                for (;;) {
-                    const i = naechsterVoll++;
-                    if (i >= ohneVolltext.length || bremse.gezogen)
-                        return;
-                    const v = await einbetten(textFuerVektor(ohneVolltext[i].inhalt));
-                    if (v?.length) {
-                        await redis.set(`${VEKTOR_PRAEFIX}${ohneVolltext[i].topic}`, packe(v));
-                        n++;
-                    }
-                    if (++fertigVoll % 100 === 0)
-                        console.log(`  Volltext ${fertigVoll}/${ohneVolltext.length}`);
-                }
-            });
-            await Promise.all(vollArbeiter);
-            console.log(`${n} Volltextvektoren geschrieben.`);
-        }
-        // ── Namensvektoren zuerst ────────────────────────────────────────────────
-        //
-        // Sie sind die Voraussetzung dafür, dass der Sortierer aus rangfolge.ts
-        // überhaupt greifen kann: ohne sie ist `naeheThema` für jede Lektion -2,
-        // und ein Merkmal mit Gewicht 0,6 trägt dann nichts bei.
-        const ohneNamen = lektionen.filter((l) => !namenDa.has(l.topic));
-        console.log(`${namenDa.size} Lektionen haben einen Namensvektor, ${ohneNamen.length} fehlen.`);
-        if (ohneNamen.length > 0) {
-            let n = 0;
-            let naechsterName = 0;
-            const namensArbeiter = Array.from({ length: parallel }, async () => {
-                for (;;) {
-                    const i = naechsterName++;
-                    if (i >= ohneNamen.length || bremse.gezogen)
-                        return;
-                    const v = await einbetten(textFuerNamensVektor(ohneNamen[i].topic));
-                    if (v?.length) {
-                        await redis.set(`${NAME_VEKTOR_PRAEFIX}${ohneNamen[i].topic}`, packe(v));
-                        n++;
-                    }
-                    if (++fertigNamen % 100 === 0)
-                        console.log(`  Namen ${fertigNamen}/${ohneNamen.length}`);
-                }
-            });
-            await Promise.all(namensArbeiter);
-            console.log(`${n} Namensvektoren geschrieben.`);
-        }
-        let offen = lektionen.filter((l) => !vorhanden.has(l.topic));
-        const koennten = wieVieleTragen(offen.map((l) => l.inhalt));
-        if (probe > 0)
-            offen = offen.slice(0, probe);
-        console.log(`${lektionen.length} Lektionen, ${vorhanden.size} haben schon Eingänge.`);
-        console.log(`${offen.length} offen, davon tragen ${koennten} einen Fehlertext.`);
-        console.log(ADMIN
-            ? `Admin-Schlüssel gesetzt — ${parallel} gleichzeitig, Notbremse bei 10x 429.`
-            : `KEIN Admin-Schlüssel — gedrosselt mit ${parallel} gleichzeitig. Das dauert.`);
-        let fertig = 0;
-        let geschrieben = 0;
-        let leer = 0;
-        const begonnen = Date.now();
-        let naechster = 0;
-        const arbeiter = Array.from({ length: parallel }, async () => {
-            for (;;) {
-                const i = naechster++;
-                if (i >= offen.length || bremse.gezogen)
-                    return;
-                const l = offen[i];
-                try {
-                    const n = await schreibeEingaenge(redis, l.topic, l.inhalt, einbetten);
-                    if (n > 0)
-                        geschrieben += n;
-                    else
-                        leer++;
-                }
-                catch {
-                    leer++;
-                }
-                fertig++;
-                if (fertig % 50 === 0) {
-                    const proSek = fertig / ((Date.now() - begonnen) / 1000);
-                    console.log(`  ${fertig}/${offen.length}  (${proSek.toFixed(1)}/s, 429er: ${bremse.stand})`);
-                }
-            }
-        });
-        await Promise.all(arbeiter);
-        const dauer = ((Date.now() - begonnen) / 1000).toFixed(0);
-        console.log(`Fertig in ${dauer} s. ${geschrieben} Eingänge für ${offen.length - leer} Lektionen.`);
-        console.log(`${leer} Lektionen tragen keinen Fehlertext — die bleiben ohne Eingang.`);
-        if (bremse.gezogen) {
-            console.error(`NOTBREMSE: ${bremse.stand} mal HTTP 429 — abgebrochen. Ein zweiter Lauf holt den Rest.`);
-            process.exit(4);
-        }
-    }
-    finally {
-        redis.disconnect();
-    }
-}
-const direktGestartet = process.argv[1]?.replace(/\\/g, '/').endsWith('/eingaenge-nachruesten.ts');
-if (direktGestartet && process.argv.includes('--selbstprobe'))
-    selbstprobe();
-else if (direktGestartet)
-    void main();
-//# sourceMappingURL=eingaenge-nachruesten.js.map
+import{Redis as K}from"ioredis";import{schreibeEingaenge as M,fehlertexteAus as W,eingangsText as J,EINGANG_PRAEFIX as X}from"./eingaenge.js";import{NAME_VEKTOR_PRAEFIX as F,VEKTOR_PRAEFIX as D,packe as P,textFuerNamensVektor as j,textFuerVektor as B}from"./bedeutung.js";const T="cachly:lesson:best:";class H{grenze;zaehler=0;constructor(o=10){this.grenze=o}melde429(){this.zaehler++}get gezogen(){return this.zaehler>=this.grenze}get stand(){return this.zaehler}}function L(c){return c.filter(o=>W(J(o)).length>0).length}function q(){const c=[],o=($,r)=>{c.push([$,r])},N={what_worked:'Der Worker meldete "No space left on device".'};o("z\xE4hlt nur Lektionen mit Fehlertext",L([N,{what_worked:"Wir haben die Reihenfolge der Schritte getauscht."},N])===2),o("leerer Bestand ergibt null",L([])===0);const f=new H(3);f.melde429(),f.melde429(),o("zwei von drei reichen nicht",!f.gezogen),f.melde429(),o("drei ziehen die Bremse",f.gezogen);let a=0;for(const[$,r]of c)console.log(`${r?"ok  ":"ROT "} ${$}`),r||a++;console.log(a===0?"Selbstprobe bestanden.":`Selbstprobe ROT: ${a} von ${c.length}.`),process.exit(a===0?0:1)}async function Q(){const c=process.argv.slice(2),o=m=>{const s=c.indexOf(`--${m}`);return s!==-1?c[s+1]:void 0},N=process.env.CACHLY_REDIS_URL??process.env.REDIS_URL,R=process.env.CACHLY_API_URL??"https://api.cachly.dev",f=process.env.CACHLY_JWT??"",a=process.env.CACHLY_ADMIN_KEY??"";N||(console.error("NICHT GELAUFEN: CACHLY_REDIS_URL oder REDIS_URL fehlt."),process.exit(2)),f||(console.error("NICHT GELAUFEN: CACHLY_JWT fehlt."),process.exit(2));const $=Number(o("probe")??"0"),r=Number(o("parallel")??(a?"6":"2")),d=new H(10),x=async m=>{for(let s=0;s<4;s++){if(d.gezogen)return null;try{const l={"Content-Type":"application/json",Authorization:`Bearer ${f}`};a&&(l["X-Admin-Key"]=a);const b=await fetch(`${R}/api/v1/embed`,{method:"POST",headers:l,body:JSON.stringify({text:m.slice(0,2e3)}),signal:AbortSignal.timeout(6e4)});if(b.status===429){d.melde429(),await new Promise(E=>setTimeout(E,2e3*(s+1)));continue}if(!b.ok)return null;const k=await b.json();return k.embedding??k.data?.[0]?.embedding??null}catch{await new Promise(l=>setTimeout(l,800*(s+1)))}}return null},u=new K(N,{maxRetriesPerRequest:2,connectTimeout:8e3});try{const m=[];let s="0";do{const[e,t]=await u.scan(s,"MATCH",`${T}*`,"COUNT",500);s=e,m.push(...t)}while(s!=="0");m.length===0&&(console.error(`NICHT GELAUFEN: keine Lektionen unter ${T}* \u2014 falsche Instanz?`),process.exit(3));const l=[];for(let e=0;e<m.length;e+=100){const t=m.slice(e,e+100),n=await u.mget(...t);for(const[g,i]of n.entries())if(i)try{const h=JSON.parse(i),S=typeof h.topic=="string"&&h.topic?h.topic:t[g].slice(T.length);S&&l.push({topic:S,inhalt:h})}catch{}}const b=async e=>{const t=new Set;let n="0";do{const[g,i]=await u.scan(n,"MATCH",`${e}*`,"COUNT",500);n=g;for(const h of i)t.add(h.slice(e.length))}while(n!=="0");return t};let k=0;const E=await b(X),y=await b(F),C=await b(D),w=l.filter(e=>!C.has(e.topic));if(console.log(`${C.size} Lektionen haben einen Volltextvektor, ${w.length} fehlen.`),w.length>0){let e=0,t=0,n=0;const g=Array.from({length:r},async()=>{for(;;){const i=n++;if(i>=w.length||d.gezogen)return;const h=await x(B(w[i].inhalt));h?.length&&(await u.set(`${D}${w[i].topic}`,P(h)),e++),++t%100===0&&console.log(`  Volltext ${t}/${w.length}`)}});await Promise.all(g),console.log(`${e} Volltextvektoren geschrieben.`)}const A=l.filter(e=>!y.has(e.topic));if(console.log(`${y.size} Lektionen haben einen Namensvektor, ${A.length} fehlen.`),A.length>0){let e=0,t=0;const n=Array.from({length:r},async()=>{for(;;){const g=t++;if(g>=A.length||d.gezogen)return;const i=await x(j(A[g].topic));i?.length&&(await u.set(`${F}${A[g].topic}`,P(i)),e++),++k%100===0&&console.log(`  Namen ${k}/${A.length}`)}});await Promise.all(n),console.log(`${e} Namensvektoren geschrieben.`)}let p=l.filter(e=>!E.has(e.topic));const V=L(p.map(e=>e.inhalt));$>0&&(p=p.slice(0,$)),console.log(`${l.length} Lektionen, ${E.size} haben schon Eing\xE4nge.`),console.log(`${p.length} offen, davon tragen ${V} einen Fehlertext.`),console.log(a?`Admin-Schl\xFCssel gesetzt \u2014 ${r} gleichzeitig, Notbremse bei 10x 429.`:`KEIN Admin-Schl\xFCssel \u2014 gedrosselt mit ${r} gleichzeitig. Das dauert.`);let z=0,_=0,v=0;const I=Date.now();let U=0;const Y=Array.from({length:r},async()=>{for(;;){const e=U++;if(e>=p.length||d.gezogen)return;const t=p[e];try{const n=await M(u,t.topic,t.inhalt,x);n>0?_+=n:v++}catch{v++}if(z++,z%50===0){const n=z/((Date.now()-I)/1e3);console.log(`  ${z}/${p.length}  (${n.toFixed(1)}/s, 429er: ${d.stand})`)}}});await Promise.all(Y);const G=((Date.now()-I)/1e3).toFixed(0);console.log(`Fertig in ${G} s. ${_} Eing\xE4nge f\xFCr ${p.length-v} Lektionen.`),console.log(`${v} Lektionen tragen keinen Fehlertext \u2014 die bleiben ohne Eingang.`),d.gezogen&&(console.error(`NOTBREMSE: ${d.stand} mal HTTP 429 \u2014 abgebrochen. Ein zweiter Lauf holt den Rest.`),process.exit(4))}finally{u.disconnect()}}const O=process.argv[1]?.replace(/\\/g,"/").endsWith("/eingaenge-nachruesten.ts");O&&process.argv.includes("--selbstprobe")?q():O&&Q();export{L as wieVieleTragen};

package/dist/src/eingaenge.js

@@ -1,260 +1,2 @@
-/**
- * Eingänge: die zweite Tür zu einer Lektion.
- *
- * ── Was gemessen wurde, und was daraus folgt ────────────────────────────────
- *
- * Am 20.08.2026 an 499 echten Lektionen mit zwei unabhängigen 100-Fragen-Sätzen
- * (`.agent/cachly/tor0-tor1-ergebnis.md`):
- *
- *   Findequote@3, frischer Prüfsatz
- *     heute, nur Volltextvektor                              52 %
- *     Eingänge in der Vorauswahl                             56 %
- *     dazu das Merkmal "bester Eingang" im Sortierer         58 %
- *     alle Eingänge AUSSER den Fehlertexten                  52 %   ← null Gewinn
- *
- * Die letzte Zeile ist die wichtigste: von fünf ausprobierten Türarten trägt
- * GENAU EINE. Der erste Satz von what_worked bringt nichts, die Übersetzung
- * bringt nichts, der Themenname steckt längst im Sortierer. Deshalb baut
- * dieses Modul nur die Fehlertexte — alles andere wäre Speicher ohne Wirkung.
- *
- * ── Warum ausgerechnet der Fehlertext ───────────────────────────────────────
- *
- * Er ist ein scharfer Schlüssel. Nutzer fügen Meldungen wörtlich ein; passt der
- * Schlüssel, zieht er die Lektion nach ganz vorn. Der Preis steht in derselben
- * Messung und wird hier offen genannt: dieselben Eingänge SENKEN die Decke von
- * 89 auf 86 % — sie ziehen auch falsche Lektionen in die Vorauswahl. Für den
- * Nutzer zählt trotzdem die Findequote: er sieht drei Lektionen, nicht 25.
- *
- * ── Eine Wahrheit ──────────────────────────────────────────────────────────
- *
- * Die Extraktion stand zuerst im Messwerkzeug (src/bench/eingaenge-b.ts). Sie
- * steht jetzt HIER, und der Bench importiert sie. Zwei Fassungen desselben
- * regulären Ausdrucks wären die Fehlerklasse, die dieses Haus am häufigsten
- * trifft — und die Messung würde etwas anderes prüfen als das Produkt.
- */
-import { kosinus, packe, entpacke } from './bedeutung.js';
-/** Wo die Eingänge einer Lektion liegen: EIN Hash je Lektion, neben ihr. */
-export const EINGANG_PRAEFIX = 'cachly:lesson:eing:';
-/** Höchstens so viele Eingänge je Lektion. Mehr Türen kosten Decke. */
-export const EINGAENGE_JE_LEKTION = 3;
-/**
- * Die Feld-Markierungen, die im Bestand IM Text stehen.
- *
- * Gemessen: `what_worked` enthält bei vielen Lektionen wörtlich
- * `</what_worked>\n<what_failed>`. Wer das nicht wegnimmt, bettet Feldnamen ein
- * und wundert sich über die Nähe zwischen zwei völlig fremden Lektionen.
- */
-export function ohneMarkierungen(text) {
-    return text.replace(/<\/?(what_worked|what_failed|context|topic)>/g, ' ').replace(/\s+/g, ' ').trim();
-}
-/**
- * Wörtliche Fehlertexte, Codes und Kernsätze aus einer Lektion.
- *
- * Fünf Muster, alle an echten Lektionen belegt:
- *   1. der GROSSGESCHRIEBENE Kernsatz am Anfang (Schreibregel des Hauses)
- *   2. alles in Anführungszeichen oder Rückwärts-Haken
- *   3. Fehlerklassen und Meldungen samt Umfeld (Error, panic, FATAL, HTTP 5xx)
- *   4. Systemfehler-Kürzel MIT Umfeld — "EACCES" allein ist als Vektor blind
- *   5. englische Meldungssätze mitten im deutschen Text
- */
-export function fehlertexteAus(text, hoechstens = EINGAENGE_JE_LEKTION) {
-    const t = ohneMarkierungen(text);
-    const aus = [];
-    const nimm = (s) => {
-        if (!s)
-            return;
-        const k = s.replace(/\s+/g, ' ').trim().replace(/^["'`„“]|["'`„“]$/g, '').trim();
-        if (k.length < 8 || k.length > 160)
-            return;
-        if (aus.some((x) => x.toLowerCase() === k.toLowerCase()))
-            return;
-        aus.push(k);
-    };
-    const gross = /^[^a-zäöüß]{15,200}?(?=[.:]|\s[a-zäöüß])/.exec(t);
-    if (gross && /[A-ZÄÖÜ]{3,}/.test(gross[0]))
-        nimm(gross[0]);
-    for (const m of t.matchAll(/[„"'`]([^„"'`\n]{8,160})[“"'`]/g))
-        nimm(m[1]);
-    for (const m of t.matchAll(/\b((?:[A-Z][a-zA-Z]*(?:Error|Exception)|panic:|FATAL|ERROR|Traceback|exit(?:ed with)? (?:code )?\d+|HTTP [45]\d{2}|status [45]\d{2})[^.\n]{0,90})/g))
-        nimm(m[1]);
-    for (const m of t.matchAll(/\b(E[A-Z]{3,10}\b[^.\n]{0,60})/g))
-        nimm(m[1]);
-    for (const m of t.matchAll(/\b((?:no such|not found|permission denied|connection refused|no space left|too many|already exists|cannot|failed to|unable to)[^.,;\n]{0,70})/gi))
-        nimm(m[1]);
-    return aus.slice(0, hoechstens);
-}
-/** Der Text einer Lektion, aus dem Eingänge gezogen werden. */
-export function eingangsText(lektion) {
-    const s = (v) => (typeof v === 'string' ? v : '');
-    return `${s(lektion.what_worked)}\n${s(lektion.what_failed)}`;
-}
-/**
- * Schreibt die Eingänge einer Lektion — als EIN Hash, nicht als n Schlüssel.
- *
- * Warum ein Hash: die Eingänge gehören zusammen und werden zusammen gelesen.
- * Drei Schlüssel je Lektion wären bei 2000 Lektionen 6000 Schlüssel im SCAN.
- *
- * Der Hash wird zuerst gelöscht: hat sich der Text der Lektion geändert, sind
- * die alten Fehlertexte falsch. Eine Lektion neu zu lernen darf keine Reste
- * hinterlassen — das wäre eine zweite Wahrheit über denselben Text.
- *
- * Gibt zurück, wie viele Eingänge geschrieben wurden.
- */
-export async function schreibeEingaenge(redis, topic, lektion, einbetten) {
-    const texte = fehlertexteAus(eingangsText(lektion));
-    const schluessel = `${EINGANG_PRAEFIX}${topic}`;
-    if (texte.length === 0) {
-        // Kein Fehlertext in dieser Lektion — dann bekommt sie keinen Eingang.
-        // Eine leere Tür ist besser als eine erfundene.
-        await redis.del(schluessel);
-        return 0;
-    }
-    const felder = [];
-    for (const text of texte) {
-        const v = await einbetten(text);
-        if (v?.length)
-            felder.push(text.slice(0, 200), packe(v));
-    }
-    if (felder.length === 0)
-        return 0;
-    await redis.del(schluessel);
-    await redis.hset(schluessel, ...felder);
-    return felder.length / 2;
-}
-/**
- * Die Eingänge aller Lektionen im Arbeitsspeicher.
- *
- * Baugleich zu `Vektorbestand` in bedeutung.ts und aus demselben Grund: bei
- * jeder Frage aus dem Speicher zu holen wäre langsamer als der Wortabgleich,
- * den wir gerade ersetzen. Der MCP-Server läuft lange, also wird einmal geladen
- * und danach nur nachgetragen.
- */
-export class Eingangsbestand {
-    frischeMs;
-    eingaenge = new Map();
-    geladen = 0;
-    constructor(frischeMs = 60_000) {
-        this.frischeMs = frischeMs;
-    }
-    get groesse() { return this.eingaenge.size; }
-    get anzahlEingaenge() {
-        let n = 0;
-        for (const vs of this.eingaenge.values())
-            n += vs.length;
-        return n;
-    }
-    /**
-     * @param praefixe welche Hashes zum Bestand gehoeren
-     *
-     * Zwei statt einem: die aus dem Text gezogenen Fehlertexte
-     * (`cachly:lesson:eing:`) und die aus der Nutzung gelernten Fragen
-     * (`cachly:lesson:pfad:`). Sie liegen getrennt, weil `schreibeEingaenge`
-     * seinen Hash vor jedem Schreiben loescht — laegen die gelernten Fragen
-     * dort, wuerde jedes erneute Lernen die gesammelte Erfahrung wegwerfen.
-     * Fuer die SUCHE sind sie dasselbe: Tueren zu derselben Lektion.
-     */
-    async aktualisiere(redis, jetzt = Date.now(), praefixe = [EINGANG_PRAEFIX, 'cachly:lesson:pfad:']) {
-        if (this.eingaenge.size > 0 && jetzt - this.geladen < this.frischeMs)
-            return;
-        const frisch = new Map();
-        for (const praefix of praefixe) {
-            const schluessel = [];
-            let cursor = '0';
-            do {
-                const [next, gefunden] = await redis.scan(cursor, 'MATCH', `${praefix}*`, 'COUNT', 500);
-                cursor = next;
-                schluessel.push(...gefunden);
-            } while (cursor !== '0');
-            for (const k of schluessel) {
-                const hash = await redis.hgetall(k);
-                const topic = k.slice(praefix.length);
-                const vs = frisch.get(topic) ?? [];
-                for (const roh of Object.values(hash)) {
-                    const v = entpacke(roh);
-                    if (v)
-                        vs.push(v);
-                }
-                if (vs.length)
-                    frisch.set(topic, vs);
-            }
-        }
-        this.eingaenge = frisch;
-        this.geladen = jetzt;
-    }
-    /**
-     * Die Nähe zum BESTEN Eingang einer Lektion. -2, wenn sie keinen hat.
-     *
-     * Maximum, nicht Mittelwert: eine Lektion wird über ihre passendste Tür
-     * gefunden, und die anderen dürfen schlecht passen. Der Mittelwert würde
-     * Lektionen mit vielen Türen bestrafen — gemessen und belegt am 20.08.
-     */
-    besteNaehe(frage, topic) {
-        const vs = this.eingaenge.get(topic);
-        if (!vs?.length)
-            return -2;
-        let best = -2;
-        for (const v of vs) {
-            const k = kosinus(frage, v);
-            if (k > best)
-                best = k;
-        }
-        return best;
-    }
-    /**
-     * Die MITTLERE Nähe über alle Eingänge einer Lektion. -2, wenn sie keine hat.
-     *
-     * Sie ersetzt `besteNaehe` nicht, sie steht daneben. Am 21.08.2026 wurde
-     * "Mittelwert STATT Maximum" gemessen und verworfen — er verlor auf der
-     * Findequote@3 (55 und 62 Prozent gegen 58 und 63).
-     *
-     * Dieselbe Messung zeigte aber, dass die beiden ENTGEGENGESETZT ziehen: das
-     * Maximum gewinnt auf @3, der Mittelwert auf Platz 1, gleichgerichtet auf
-     * zwei unabhängigen Fragensätzen. Sie messen Verschiedenes.
-     *
-     *   Maximum      "gibt es EINE Tür, die genau auf diese Frage passt?"
-     *   Mittelwert   "passt die Lektion als GANZE zu dieser Frage?"
-     *
-     * Das Maximum allein belohnt eine Lektion, die zufällig eine gut passende
-     * Tür trägt und sonst am Thema vorbeigeht. Der Mittelwert allein bestraft
-     * eine breit aufgestellte Lektion, die nur mit einer Tür trifft. Nebeneinander
-     * heben sich die beiden Fehler teilweise auf.
-     *
-     * Ohne Schwelle, anders als das Maximum: ein Mittelwert liegt naturgemäß
-     * niedriger, und die für das Maximum abgetastete 0,5 würde ihn fast überall
-     * auf "kein Wert" drücken — das Merkmal wäre still abgeschaltet.
-     */
-    mittelNaehe(frage, topic) {
-        const vs = this.eingaenge.get(topic);
-        if (!vs?.length)
-            return -2;
-        let summe = 0;
-        for (const v of vs)
-            summe += kosinus(frage, v);
-        return summe / vs.length;
-    }
-    /** Die ähnlichsten Lektionen, je Lektion ihr bester Eingang. */
-    aehnlichste(frage, anzahl) {
-        const aus = [];
-        for (const topic of this.eingaenge.keys()) {
-            aus.push({ topic, naehe: this.besteNaehe(frage, topic) });
-        }
-        aus.sort((a, b) => b.naehe - a.naehe);
-        return aus.slice(0, anzahl);
-    }
-}
-/**
- * Das Gewicht des Merkmals "bester Eingang" im Sortierer.
- *
- * Gemessen am 20.08.2026: 0,3 / 0,5 / 0,8 / 1,3 ergeben 57 / 58 / 57 / 57 %
- * Findequote@3. Das Merkmal ist also unempfindlich gegen sein Gewicht — wer
- * hier weiterdreht, misst Rauschen. 0,5 ist die Mitte des flachen Bereichs.
- */
-export const EINGANG_GEWICHT = 0.5;
-export function beurteileDeckung(lektionen, vektoren) {
-    if (lektionen === 0)
-        return 'gut'; // Ein leeres Brain ist nicht krank.
-    if (vektoren === 0)
-        return 'aus';
-    return (vektoren / lektionen) * 100 < 90 ? 'luecke' : 'gut';
-}
-//# sourceMappingURL=eingaenge.js.map
+import{kosinus as u,packe as m,entpacke as x}from"./bedeutung.js";const p="cachly:lesson:eing:",w=3;function A(c){return c.replace(/<\/?(what_worked|what_failed|context|topic)>/g," ").replace(/\s+/g," ").trim()}function E(c,t=w){const n=A(c),o=[],e=s=>{if(!s)return;const a=s.replace(/\s+/g," ").trim().replace(/^["'`„“]|["'`„“]$/g,"").trim();a.length<8||a.length>160||o.some(i=>i.toLowerCase()===a.toLowerCase())||o.push(a)},r=/^[^a-zäöüß]{15,200}?(?=[.:]|\s[a-zäöüß])/.exec(n);r&&/[A-ZÄÖÜ]{3,}/.test(r[0])&&e(r[0]);for(const s of n.matchAll(/[„"'`]([^„"'`\n]{8,160})[“"'`]/g))e(s[1]);for(const s of n.matchAll(/\b((?:[A-Z][a-zA-Z]*(?:Error|Exception)|panic:|FATAL|ERROR|Traceback|exit(?:ed with)? (?:code )?\d+|HTTP [45]\d{2}|status [45]\d{2})[^.\n]{0,90})/g))e(s[1]);for(const s of n.matchAll(/\b(E[A-Z]{3,10}\b[^.\n]{0,60})/g))e(s[1]);for(const s of n.matchAll(/\b((?:no such|not found|permission denied|connection refused|no space left|too many|already exists|cannot|failed to|unable to)[^.,;\n]{0,70})/gi))e(s[1]);return o.slice(0,t)}function b(c){const t=n=>typeof n=="string"?n:"";return`${t(c.what_worked)}
+${t(c.what_failed)}`}async function N(c,t,n,o){const e=E(b(n)),r=`${p}${t}`;if(e.length===0)return await c.del(r),0;const s=[];for(const a of e){const i=await o(a);i?.length&&s.push(a.slice(0,200),m(i))}return s.length===0?0:(await c.del(r),await c.hset(r,...s),s.length/2)}class T{frischeMs;eingaenge=new Map;geladen=0;constructor(t=6e4){this.frischeMs=t}get groesse(){return this.eingaenge.size}get anzahlEingaenge(){let t=0;for(const n of this.eingaenge.values())t+=n.length;return t}async aktualisiere(t,n=Date.now(),o=[p,"cachly:lesson:pfad:"]){if(this.eingaenge.size>0&&n-this.geladen<this.frischeMs)return;const e=new Map;for(const r of o){const s=[];let a="0";do{const[i,h]=await t.scan(a,"MATCH",`${r}*`,"COUNT",500);a=i,s.push(...h)}while(a!=="0");for(const i of s){const h=await t.hgetall(i),g=i.slice(r.length),l=e.get(g)??[];for(const d of Object.values(h)){const f=x(d);f&&l.push(f)}l.length&&e.set(g,l)}}this.eingaenge=e,this.geladen=n}besteNaehe(t,n){const o=this.eingaenge.get(n);if(!o?.length)return-2;let e=-2;for(const r of o){const s=u(t,r);s>e&&(e=s)}return e}mittelNaehe(t,n){const o=this.eingaenge.get(n);if(!o?.length)return-2;let e=0;for(const r of o)e+=u(t,r);return e/o.length}aehnlichste(t,n){const o=[];for(const e of this.eingaenge.keys())o.push({topic:e,naehe:this.besteNaehe(t,e)});return o.sort((e,r)=>r.naehe-e.naehe),o.slice(0,n)}}const _=.5;function v(c,t){return c===0?"gut":t===0?"aus":t/c*100<90?"luecke":"gut"}export{w as EINGAENGE_JE_LEKTION,_ as EINGANG_GEWICHT,p as EINGANG_PRAEFIX,T as Eingangsbestand,v as beurteileDeckung,b as eingangsText,E as fehlertexteAus,A as ohneMarkierungen,N as schreibeEingaenge};