@cachly-dev/mcp-server 0.10.129 → 0.10.131

package/dist/src/autor.js

@@ -1,136 +1 @@
-import { execSync } from 'node:child_process';
-export const echterGitLeser = (cwd) => (schluessel) => {
-    try {
-        return execSync(`git config ${schluessel}`, {
-            cwd,
-            encoding: 'utf-8',
-            stdio: 'pipe',
-            timeout: 1500,
-        }).trim();
-    }
-    catch {
-        return '';
-    }
-};
-/**
- * Einen Namen auf die Form bringen, in der Autoren gespeichert werden.
- *
- * Klein geschrieben und ohne Leerzeichen: "Heinrich Neb" wird zu "heinrich".
- * Das ist keine Kosmetik — brain_who_knows, team_recall und die
- * Wiederverwendungs-Zaehlung vergleichen Autoren als Zeichenketten. "Heinrich"
- * und "heinrich" waeren zwei Menschen.
- */
-export function normalisiere(roh) {
-    const t = (roh ?? '').trim();
-    if (!t)
-        return '';
-    // Nur der Rufname: Nachnamen aendern sich (Heirat), Rufnamen selten. Und
-    // ein Nachname im Autorenfeld ist eine Personendatei mehr, die niemand
-    // gebeten hat anzulegen.
-    const erster = t.split(/[\s.]+/)[0] ?? '';
-    return erster
-        .toLowerCase()
-        .replace(/[^a-z0-9_-]/g, '')
-        .slice(0, 32);
-}
-/**
- * Ausdrueckliche Wortmeldung "ohne meinen Namen".
- *
- * Ohne diesen Weg gaebe es keinen mehr: seit der Name aus git hergeleitet
- * wird, bekaeme JEDE Lektion einen Autor, auch die, bei der der Mensch das
- * nicht will. Eine private Notiz ueber einen Kunden, ein Fund, den man nicht
- * an sich haengen will — das muss weiterhin gehen, und zwar sichtbar statt
- * durch Weglassen.
- *
- * Der Test, der beim Umbau rot wurde, hat genau diese Luecke gezeigt: er
- * speicherte eine Lektion ohne Autor und erwartete, dass skill_gaps sie
- * anmeckert. Das ging vorher versehentlich, jetzt geht es absichtlich.
- */
-const ANONYM = new Set(['-', 'anonym', 'anonymous', 'none', 'kein', 'off']);
-export function ermittleAutor(input) {
-    const rohUeb = (input.uebergeben ?? '').trim().toLowerCase();
-    if (ANONYM.has(rohUeb))
-        return { autor: '', quelle: 'anonym' };
-    const rohEnv = (input.umgebung ?? '').trim().toLowerCase();
-    if (ANONYM.has(rohEnv))
-        return { autor: '', quelle: 'anonym' };
-    const ueb = normalisiere(input.uebergeben ?? '');
-    if (ueb)
-        return { autor: ueb, quelle: 'uebergeben' };
-    const env = normalisiere(input.umgebung ?? '');
-    if (env)
-        return { autor: env, quelle: 'umgebung' };
-    const name = normalisiere(input.git('user.name'));
-    if (name)
-        return { autor: name, quelle: 'git-name' };
-    const mail = input.git('user.email');
-    const vorDemAt = normalisiere((mail ?? '').split('@')[0] ?? '');
-    if (vorDemAt)
-        return { autor: vorDemAt, quelle: 'git-mail' };
-    return { autor: '', quelle: 'unbekannt' };
-}
-/**
- * Der Mitautor — standardmaessig AUS.
- *
- * Heinrich: "Wir koennen im gleichen Zuge ja auch zum Beispiel claude als
- * Co-Author nehmen, wenn der User das moechte? Einstellungssache,
- * standardmaessig aber aus."
- *
- * Aus zwei Gruenden aus: erstens gehoert die Entscheidung dem Menschen, und
- * zweitens wuerde ein automatisch gesetzter Mitautor die Zahl, um die es hier
- * geht — wie viele Lektionen einen MENSCHEN als Autor haben — sofort wieder
- * unbrauchbar machen.
- *
- * Eingeschaltet wird er mit
- *   brain_set_pref(key="coauthor", value="claude")
- * und wieder aus mit value="" oder "off".
- */
-export const COAUTHOR_PREF_KEY = 'coauthor';
-/** Aus dem gespeicherten Wert den Mitautor lesen — leer heisst aus. */
-export function coautorAus(prefWert) {
-    const t = (prefWert ?? '').trim().toLowerCase();
-    if (!t || t === 'off' || t === 'false' || t === '0' || t === 'none')
-        return '';
-    return normalisiere(t);
-}
-/**
- * Wie der Autor gespeichert wird, wenn ein Mitautor eingeschaltet ist.
- *
- * "heinrich+claude" — ein Feld, kein zweites. Ein zweites Feld haette jede
- * Abfrage im ganzen Haus anfassen muessen (who_knows, team_recall,
- * reuse_pairs, das Briefing), und die Zahl "wie viele Lektionen haben einen
- * Autor" waere dabei zweideutig geworden.
- *
- * Der Mensch steht VORN. Wer die Zeichenkette an "+" trennt, bekommt zuerst
- * den, der die Entscheidung getroffen hat.
- */
-export function mitCoautor(autor, coautor) {
-    if (!autor)
-        return '';
-    if (!coautor || coautor === autor)
-        return autor;
-    return `${autor}+${coautor}`;
-}
-/** Nur der Mensch, ohne Mitautor — fuer Zaehlungen und Vergleiche. */
-export function nurMensch(autorFeld) {
-    return (autorFeld ?? '').split('+')[0] ?? '';
-}
-/**
- * Ein Satz an den Aufrufer, wenn kein Autor ermittelt werden konnte.
- *
- * Wieder ein HINWEIS und keine Ablehnung: eine abgelehnte Lektion ist immer
- * schlechter als eine ohne Autor. Aber schweigen waere falsch — genau das
- * Schweigen hat die 195 erzeugt.
- */
-export function autorHinweis(h) {
-    if (h.autor)
-        return null;
-    // Wer ausdruecklich anonym speichert, bekommt keine Belehrung.
-    if (h.quelle === 'anonym')
-        return null;
-    return (`👤 **Kein Autor ermittelt** — weder \`author\`, noch \`CACHLY_AUTHOR\`, noch \`git config user.name\`. ` +
-        `Ohne Autor zählt diese Lektion nicht als Team-Wissen: \`brain_who_knows\` findet niemanden und ` +
-        `Wiederverwendung über Personengrenzen bleibt ungezählt. Ein \`git config user.name "Vorname"\` ` +
-        `im Projekt genügt für alle künftigen Lektionen.`);
-}
-//# sourceMappingURL=autor.js.map
+import{execSync as c}from"node:child_process";const f=e=>n=>{try{return c(`git config ${n}`,{cwd:e,encoding:"utf-8",stdio:"pipe",timeout:1500}).trim()}catch{return""}};function t(e){const n=(e??"").trim();return n?(n.split(/[\s.]+/)[0]??"").toLowerCase().replace(/[^a-z0-9_-]/g,"").slice(0,32):""}const a=new Set(["-","anonym","anonymous","none","kein","off"]);function g(e){const n=(e.uebergeben??"").trim().toLowerCase();if(a.has(n))return{autor:"",quelle:"anonym"};const r=(e.umgebung??"").trim().toLowerCase();if(a.has(r))return{autor:"",quelle:"anonym"};const o=t(e.uebergeben??"");if(o)return{autor:o,quelle:"uebergeben"};const u=t(e.umgebung??"");if(u)return{autor:u,quelle:"umgebung"};const i=t(e.git("user.name"));if(i)return{autor:i,quelle:"git-name"};const l=e.git("user.email"),s=t((l??"").split("@")[0]??"");return s?{autor:s,quelle:"git-mail"}:{autor:"",quelle:"unbekannt"}}const b="coauthor";function h(e){const n=(e??"").trim().toLowerCase();return!n||n==="off"||n==="false"||n==="0"||n==="none"?"":t(n)}function p(e,n){return e?!n||n===e?e:`${e}+${n}`:""}function w(e){return(e??"").split("+")[0]??""}function d(e){return e.autor||e.quelle==="anonym"?null:'\u{1F464} **Kein Autor ermittelt** \u2014 weder `author`, noch `CACHLY_AUTHOR`, noch `git config user.name`. Ohne Autor z\xE4hlt diese Lektion nicht als Team-Wissen: `brain_who_knows` findet niemanden und Wiederverwendung \xFCber Personengrenzen bleibt ungez\xE4hlt. Ein `git config user.name "Vorname"` im Projekt gen\xFCgt f\xFCr alle k\xFCnftigen Lektionen.'}export{b as COAUTHOR_PREF_KEY,d as autorHinweis,h as coautorAus,f as echterGitLeser,g as ermittleAutor,p as mitCoautor,t as normalisiere,w as nurMensch};

package/dist/src/bauabdruck.js

@@ -1,93 +1 @@
-// Bauabdruck: zeigt, welcher Stand des Servers gerade laeuft.
-//
-// Zwei Bauten koennen dieselbe Versionsnummer tragen und trotzdem
-// verschiedenen Code ausfuehren. Gemessen am 20.08.2026: package.json sagte
-// beim installierten UND beim aktuellen Server 0.10.124 — der installierte
-// dist/ hatte den Code aus instances.ts (get_connection_string) trotzdem
-// nicht. Von aussen war das nicht zu unterscheiden. Der Bauabdruck macht den
-// Commit sichtbar, nicht nur die Versionsnummer.
-//
-// Die echten Werte kommen aus scripts/bauabdruck.mjs, das beim Bauen
-// (`npm run build`) eine JSON-Datei daneben schreibt. Diese Datei ist
-// generiert und steht darum in .gitignore. DIESE Datei (bauabdruck.ts) ist
-// eingecheckt und bleibt es — sie ist die Rueckfall-Fassung, die einspringt,
-// wenn noch nie gebaut wurde. Genau das prueft CI im Schritt "Type check":
-// `tsc --noEmit` laeuft dort OHNE vorherigen `npm run build`.
-import { existsSync, readFileSync } from 'node:fs';
-import { dirname, join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-/** Rueckfall, solange kein Bauabdruck generiert wurde (kein Absturz, keine Erfindung). */
-export const RUECKFALL_BAUABDRUCK = {
-    version: 'unbekannt',
-    commit: 'unbekannt',
-    gebautAm: 'unbekannt',
-};
-function istBauabdruck(wert) {
-    if (typeof wert !== 'object' || wert === null)
-        return false;
-    const w = wert;
-    return typeof w.version === 'string' && typeof w.commit === 'string' && typeof w.gebautAm === 'string';
-}
-/**
- * Laedt den generierten Bauabdruck aus dem eigenen Verzeichnis.
- *
- * Faellt auf RUECKFALL_BAUABDRUCK zurueck, wenn die Datei fehlt, kein gueltiges
- * JSON enthaelt oder die falsche Form hat — ein fehlender Bauabdruck ist kein
- * Grund, den Server gar nicht erst zu starten.
- */
-export function ladeBauabdruck(verzeichnis = dirname(fileURLToPath(import.meta.url))) {
-    const pfad = join(verzeichnis, 'bauabdruck-daten.generiert.json');
-    if (!existsSync(pfad))
-        return RUECKFALL_BAUABDRUCK;
-    try {
-        const wert = JSON.parse(readFileSync(pfad, 'utf-8'));
-        return istBauabdruck(wert) ? wert : RUECKFALL_BAUABDRUCK;
-    }
-    catch {
-        return RUECKFALL_BAUABDRUCK;
-    }
-}
-/** Der Bauabdruck dieses laufenden Prozesses — einmal beim Start geladen. */
-export const bauabdruck = ladeBauabdruck();
-/** Ab wie vielen Tagen der Bauabdruck in brain_doctor als alt gilt (🟡). */
-export const ALTER_SCHWELLE_TAGE = 14;
-/**
- * Der Waechter: ist der Bauabdruck aelter als die Schwelle?
- *
- * Eigene Funktion, damit sie einzeln aufrufbar und pruefbar ist — aus
- * demselben Grund wie beurteileDeckung in eingaenge.ts: ein Wächter, den man
- * nicht einzeln aufrufen kann, ist ein Wächter, dessen Nein niemand je sieht.
- * "unbekannt" gilt NICHT als alt — ein Server, der nie gebaut wurde, ist ein
- * anderer Zustand als einer, der seit Wochen laeuft.
- */
-export function istAlt(gebautAm, jetzt = new Date()) {
-    const datum = new Date(gebautAm);
-    if (Number.isNaN(datum.getTime()))
-        return false;
-    const tage = (jetzt.getTime() - datum.getTime()) / 86_400_000;
-    return tage > ALTER_SCHWELLE_TAGE;
-}
-/**
- * Baut die Zeile fuer brain_doctor — Form und Ton wie die Zeile
- * "Semantic coverage" dort: Emoji, Fettdruck-Label, Zahlen statt Adjektive.
- *
- * Ein Server, der seit Wochen laeuft, ist kein Fehler — aber man muss es
- * sehen koennen. Darum 🟡 statt ❌ fuer den Altersfall.
- */
-export function formatiereBauabdruck(a, jetzt = new Date()) {
-    if (a.gebautAm === 'unbekannt') {
-        return `❔ **Bauabdruck: unbekannt** — noch kein \`npm run build\` gelaufen, Version/Commit nicht feststellbar`;
-    }
-    const datum = new Date(a.gebautAm);
-    const gueltigesDatum = !Number.isNaN(datum.getTime());
-    const alt = gueltigesDatum && istAlt(a.gebautAm, jetzt);
-    const tage = gueltigesDatum ? Math.floor((jetzt.getTime() - datum.getTime()) / 86_400_000) : null;
-    const alterText = tage === null ? '' : ` (vor ${tage} Tag${tage === 1 ? '' : 'en'})`;
-    const emoji = alt ? '🟡' : '✅';
-    const hinweis = alt
-        ? ` — laeuft laenger als ${ALTER_SCHWELLE_TAGE} Tage. Kein Fehler, aber sichtbar.`
-        : '';
-    const datumsText = gueltigesDatum ? a.gebautAm.slice(0, 10) : a.gebautAm;
-    return `${emoji} **Bauabdruck:** v${a.version} · commit \`${a.commit}\` · gebaut am ${datumsText}${alterText}${hinweis}`;
-}
-//# sourceMappingURL=bauabdruck.js.map
+import{existsSync as g,readFileSync as l}from"node:fs";import{dirname as f,join as p}from"node:path";import{fileURLToPath as d}from"node:url";const o={version:"unbekannt",commit:"unbekannt",gebautAm:"unbekannt"};function k(t){if(typeof t!="object"||t===null)return!1;const e=t;return typeof e.version=="string"&&typeof e.commit=="string"&&typeof e.gebautAm=="string"}function A(t=f(d(import.meta.url))){const e=p(t,"bauabdruck-daten.generiert.json");if(!g(e))return o;try{const n=JSON.parse(l(e,"utf-8"));return k(n)?n:o}catch{return o}}const y=A(),i=14;function T(t,e=new Date){const n=new Date(t);return Number.isNaN(n.getTime())?!1:(e.getTime()-n.getTime())/864e5>i}function B(t,e=new Date){if(t.gebautAm==="unbekannt")return"\u2754 **Bauabdruck: unbekannt** \u2014 noch kein `npm run build` gelaufen, Version/Commit nicht feststellbar";const n=new Date(t.gebautAm),r=!Number.isNaN(n.getTime()),u=r&&T(t.gebautAm,e),a=r?Math.floor((e.getTime()-n.getTime())/864e5):null,m=a===null?"":` (vor ${a} Tag${a===1?"":"en"})`,s=u?"\u{1F7E1}":"\u2705",c=u?` \u2014 laeuft laenger als ${i} Tage. Kein Fehler, aber sichtbar.`:"",b=r?t.gebautAm.slice(0,10):t.gebautAm;return`${s} **Bauabdruck:** v${t.version} \xB7 commit \`${t.commit}\` \xB7 gebaut am ${b}${m}${c}`}export{i as ALTER_SCHWELLE_TAGE,o as RUECKFALL_BAUABDRUCK,y as bauabdruck,B as formatiereBauabdruck,T as istAlt,A as ladeBauabdruck};

package/dist/src/bedeutung.js

@@ -1,323 +1,2 @@
-/**
- * Bedeutungsabgleich: die Frage findet die Lektion auch ohne gemeinsame Wörter.
- *
- * ── Warum es das gibt ────────────────────────────────────────────────────────
- *
- * Gemessen am 19.08.2026 an 499 echten Lektionen mit 100 Fragen in Alltags-
- * sprache:
- *
- *   Verfahren            Platz 1   Top 3   MRR
- *   Wörter (bisher)        21 %    33 %   29,3 %
- *   Bedeutung (bge-m3)     40 %    60 %   51,4 %
- *
- * Der Wortabgleich war ausgereizt: nach drei Reparaturen brachten weitere
- * Eingriffe je eine Frage. Der Grund liegt in der Aufgabe, nicht in der
- * Umsetzung. Eine Frage beschreibt ein SYMPTOM, die Lektion eine URSACHE.
- * "Der Deploy hängt beim Bauen" und "No space left on device" teilen kein Wort
- * und meinen dasselbe. Kein Wörterbuch schließt diese Lücke.
- *
- * ── Und es ist SCHNELLER, nicht langsamer ───────────────────────────────────
- *
- * Das war die Überraschung. Am selben Tag gemessen:
- *
- *   Wortabgleich (heute, 499 Lektionen)   788 ms   (Mitte)
- *   Einbettung der Frage (Netzaufruf)     282 ms
- *   Vergleich gegen 494 Vektoren            0 ms   (14 ms im schlechtesten Fall)
- *
- * Der Wortabgleich baut seinen Index bei JEDER Frage neu: alle Datensätze
- * holen, zerlegen, Worthäufigkeiten und Bigramme rechnen. Das wächst linear
- * mit dem Bestand — gemessen 1,6 ms je Lektion und Frage:
- *
- *   Lektionen     50    100    250    499    998   1996
- *   Wartezeit   75ms  156ms  408ms  792ms 1601ms 3185ms
- *
- * Bei 2000 Lektionen sind das 3,2 Sekunden. Die automatische Einblendung hat
- * ein 3-Sekunden-Budget — das erklärt, warum sie nichts liefert
- * (cachly:ambient-recall-blendet-nichts-ein).
- *
- * Der Bedeutungsabgleich kostet dagegen konstant einen Netzaufruf. Er wird
- * nicht langsamer, wenn der Bestand wächst.
- *
- * ── Was das Modul NICHT tut ─────────────────────────────────────────────────
- *
- * Es ersetzt den Wortabgleich nicht. Zwei Gründe:
- *
- *   1. Ohne Netz gibt es keine Einbettung. Der Wortabgleich läuft immer.
- *   2. Gemischt sind die ersten zehn Treffer besser als bei beiden einzeln
- *      (71 % gegen 68 und 47). Wörter finden das wörtlich Genannte, Bedeutung
- *      das sinngemäß Gemeinte.
- */
-/** Wo ein Lektionsvektor liegt. Ein Schlüssel je Lektion, neben der Lektion. */
-export const VEKTOR_PRAEFIX = 'cachly:lesson:vec:';
-/**
- * Wo der Vektor des THEMENNAMENS liegt.
- *
- * Warum getrennt vom Volltextvektor: der Name ist kurz und frageähnlich, der
- * Volltext ist 1376 Zeichen lang. Eine 60-Zeichen-Frage gegen 60 Zeichen zu
- * halten ist symmetrisch, gegen 1376 nicht — der Sortierer bewertet beide
- * deshalb als eigene Merkmale (`naeheText` 1,0 und `naeheThema` 0,6).
- *
- * Gemessen am 19.08.2026: der Name allein findet nur 26 %, im Verbund trägt er
- * verlässlich. Bis zum 20.08. gab es diese Vektoren nur im Messstand
- * (korpus-gross.sicht-c.json), im Produkt nicht — der Sortierer aus
- * rangfolge.ts war deshalb auch gar nicht verdrahtet.
- */
-export const NAME_VEKTOR_PRAEFIX = 'cachly:lesson:vecname:';
-/** Der Text, aus dem der Namensvektor gebildet wird: Trennzeichen zu Wörtern. */
-export function textFuerNamensVektor(topic) {
-    return topic.replace(/[:_-]+/g, ' ').replace(/\s+/g, ' ').trim();
-}
-/**
- * Vektoren werden als base64 gespeichert, nicht als JSON-Zahlenliste.
- *
- * 1024 Zahlen als JSON sind rund 20 KB je Lektion, als Float32 sind es 4 KB.
- * Bei 500 Lektionen ist das der Unterschied zwischen 10 MB und 2 MB, die bei
- * jedem kalten Start über die Leitung gehen.
- *
- * ── Seit 20.08.2026: int8 statt float32 ────────────────────────────────────
- *
- * Gemessen an diesem Tag: von 23,6 MB im Speicher waren 11,2 MB (47 %)
- * Vektoren — 6,0 MB Lektionsvektoren und 5,2 MB Eingänge. Der Freitarif hat
- * 25 MB. Der Bestand stand bei 94 % und die nächste Lektion wäre an einem
- * Schreibfehler gescheitert.
- *
- * Eine Zahl braucht hier keine 4 Bytes. Die Vektoren sind normiert, alle Werte
- * liegen dicht beieinander, und für den Kosinus zählt die RICHTUNG. Also wird
- * je Vektor eine Skala mitgeschrieben und jede Zahl als ein Byte abgelegt.
- * Aus 4096 Bytes werden 1033 — Faktor 3,96.
- *
- * Warum weiter base64 und nicht roh: rohe Bytes müssten überall als Buffer
- * gelesen werden. Eine einzige Stelle, die weiter Text liest, macht Vektoren
- * still kaputt statt laut. Der base64-Aufschlag von einem Drittel ist billiger
- * als diese Fehlerklasse.
- *
- * ── Aufbau des neuen Formats ───────────────────────────────────────────────
- *
- *   Byte 0     Kennung 0x01
- *   Byte 1–2   uint16 LE — wie viele Zahlen
- *   Byte 3–6   float32 LE — die Skala
- *   ab Byte 7  je Zahl ein int8
- *   danach     Füllbytes, bis die Länge durch 4 geteilt den Rest 1 lässt
- *
- * Die Füllbytes sind kein Schönheitsfehler, sie sind die Unterscheidung: das
- * alte Format ist IMMER durch 4 teilbar (float32), das neue lässt immer den
- * Rest 1. Die Kennung allein würde nicht reichen — ein float32 darf zufällig
- * mit 0x01 anfangen. Zwei unabhängige Merkmale, nicht eines.
- *
- * `entpacke` liest beide Formate. Alte Vektoren bleiben gültig und werden
- * ersetzt, wenn ihre Lektion das nächste Mal geschrieben wird.
- */
-const KENNUNG_INT8 = 0x01;
-const KOPF_BYTES = 7; // Kennung(1) + Anzahl(2) + Skala(4)
-export function packe(vektor) {
-    let groesstes = 0;
-    for (const x of vektor) {
-        const a = Math.abs(x);
-        if (a > groesstes)
-            groesstes = a;
-    }
-    // Skala 1 bei einem Nullvektor: dann ist jede Zahl 0 und die Skala egal.
-    const skala = groesstes > 0 ? groesstes / 127 : 1;
-    let laenge = KOPF_BYTES + vektor.length;
-    while (laenge % 4 !== 1)
-        laenge++;
-    const b = Buffer.alloc(laenge); // alloc, nicht allocUnsafe: die Füllbytes sollen 0 sein
-    b.writeUInt8(KENNUNG_INT8, 0);
-    b.writeUInt16LE(vektor.length, 1);
-    b.writeFloatLE(skala, 3);
-    for (let i = 0; i < vektor.length; i++) {
-        const q = Math.round(vektor[i] / skala);
-        b.writeInt8(q > 127 ? 127 : q < -127 ? -127 : q, KOPF_BYTES + i);
-    }
-    return b.toString('base64');
-}
-export function entpacke(s) {
-    try {
-        const b = Buffer.from(s, 'base64');
-        if (b.byteLength === 0)
-            return null;
-        // Neues Format: Kennung UND Restklasse 1 müssen beide stimmen.
-        if (b[0] === KENNUNG_INT8 && b.byteLength % 4 === 1 && b.byteLength > KOPF_BYTES) {
-            const anzahl = b.readUInt16LE(1);
-            if (anzahl === 0 || KOPF_BYTES + anzahl > b.byteLength)
-                return null;
-            const skala = b.readFloatLE(3);
-            if (!Number.isFinite(skala))
-                return null;
-            const aus = new Array(anzahl);
-            for (let i = 0; i < anzahl; i++)
-                aus[i] = b.readInt8(KOPF_BYTES + i) * skala;
-            return aus;
-        }
-        // Altes Format: reine float32-Folge.
-        if (b.byteLength % 4 !== 0)
-            return null;
-        const f = new Float32Array(b.buffer, b.byteOffset, b.byteLength / 4);
-        return Array.from(f);
-    }
-    catch {
-        return null;
-    }
-}
-/**
- * Kosinus-Ähnlichkeit zweier Vektoren.
- *
- * Die Länge wird bei JEDEM Aufruf neu gerechnet statt einmal vorher. Das ist
- * absichtlich: gemessen liegt der gesamte Vergleich gegen 494 Vektoren bei
- * 0 ms. Eine Vorberechnung wäre eine zweite Wahrheit über denselben Vektor —
- * und der Gewinn wäre nicht messbar.
- */
-export function kosinus(a, b) {
-    if (a.length !== b.length)
-        return -1;
-    let p = 0;
-    let qa = 0;
-    let qb = 0;
-    for (let i = 0; i < a.length; i++) {
-        p += a[i] * b[i];
-        qa += a[i] * a[i];
-        qb += b[i] * b[i];
-    }
-    return qa && qb ? p / Math.sqrt(qa * qb) : 0;
-}
-/**
- * Der Text, aus dem der Vektor einer Lektion gebildet wird.
- *
- * Bewusst NICHT das rohe JSON: Feldnamen, Zeitstempel und Prüfspuren tragen
- * keine Bedeutung, verbrauchen aber vom Fenster des Einbettungsmodells. Der
- * Dienst kürzt bei rund 2000 Zeichen — gemessen liefern 2000, 4000 und 6000
- * Zeichen denselben Vektor. Was hinten steht, existiert für ihn nicht.
- */
-export function textFuerVektor(lektion) {
-    const s = (v) => (typeof v === 'string' ? v : '');
-    return [s(lektion.topic), s(lektion.what_worked), s(lektion.what_failed)]
-        .filter(Boolean).join('\n').slice(0, 2000);
-}
-/**
- * Ein Vektorbestand, der im Arbeitsspeicher bleibt.
- *
- * Warum: 494 Vektoren sind rund 2 MB. Die bei jeder Frage aus dem Speicher zu
- * holen wäre langsamer als der Wortabgleich, den wir gerade ersetzen — der
- * Gewinn wäre weg, bevor er anfängt.
- *
- * Der MCP-Server läuft lange, also wird einmal geladen und danach nur
- * nachgetragen. Die Prüfung "hat sich etwas geändert" läuft über die ANZAHL
- * der Schlüssel, nicht über ihren Inhalt: eine geänderte Lektion bekommt beim
- * Lernen sofort ihren neuen Vektor geschrieben, und dieser Bestand holt ihn
- * beim nächsten Nachladen.
- */
-export class Vektorbestand {
-    frischeMs;
-    praefix;
-    vektoren = new Map();
-    geladen = 0;
-    /**
-     * @param frischeMs wie lange ein geladener Bestand als frisch gilt
-     * @param praefix   welche Sicht — Volltext (Standard) oder Themenname
-     *
-     * Der Präfix ist ein Parameter und keine zweite Klasse: die Mechanik ist
-     * identisch (scannen, in Blöcken holen, entpacken, Gelöschtes vergessen).
-     * Zwei Klassen dafür wären zwei Orte, an denen dieselbe Änderung nachgezogen
-     * werden müsste.
-     */
-    constructor(frischeMs = 60_000, praefix = VEKTOR_PRAEFIX) {
-        this.frischeMs = frischeMs;
-        this.praefix = praefix;
-    }
-    /** Die Nähe einer Frage zu EINER Lektion. -2, wenn sie keinen Vektor hat. */
-    naehe(frage, topic) {
-        const v = this.vektoren.get(`${this.praefix}${topic}`);
-        return v ? kosinus(frage, v) : -2;
-    }
-    /**
-     * Der Vektor selbst — für die Rückkopplung, die aus den besten Treffern
-     * einen angereicherten Fragevektor baut (`reichereAn`). `null`, wenn die
-     * Lektion keinen hat; der Aufrufer filtert das weg.
-     */
-    rohvektor(topic) {
-        return this.vektoren.get(`${this.praefix}${topic}`) ?? null;
-    }
-    get groesse() { return this.vektoren.size; }
-    /** Lädt fehlende Vektoren nach. Tut nichts, wenn kürzlich geladen wurde. */
-    async aktualisiere(redis, jetzt = Date.now()) {
-        if (this.vektoren.size > 0 && jetzt - this.geladen < this.frischeMs)
-            return;
-        const schluessel = [];
-        let cursor = '0';
-        do {
-            const [next, gefunden] = await redis.scan(cursor, 'MATCH', `${this.praefix}*`, 'COUNT', 500);
-            cursor = next;
-            schluessel.push(...gefunden);
-        } while (cursor !== '0');
-        const fehlend = schluessel.filter((k) => !this.vektoren.has(k));
-        for (let i = 0; i < fehlend.length; i += 100) {
-            const block = fehlend.slice(i, i + 100);
-            const werte = await redis.mget(...block);
-            for (const [j, roh] of werte.entries()) {
-                if (!roh)
-                    continue;
-                const v = entpacke(roh);
-                if (v)
-                    this.vektoren.set(block[j], v);
-            }
-        }
-        // Gelöschte Lektionen wieder loswerden.
-        if (schluessel.length < this.vektoren.size) {
-            const da = new Set(schluessel);
-            for (const k of [...this.vektoren.keys()])
-                if (!da.has(k))
-                    this.vektoren.delete(k);
-        }
-        this.geladen = jetzt;
-    }
-    /**
-     * Die ähnlichsten Lektionen zu einem Fragevektor.
-     *
-     * Zurück kommen die THEMEN, nicht die Schlüssel — der Aufrufer arbeitet mit
-     * Themen und soll das Schlüsselformat nicht kennen müssen.
-     */
-    aehnlichste(frage, anzahl) {
-        const aus = [];
-        for (const [k, v] of this.vektoren) {
-            aus.push({ topic: k.slice(this.praefix.length), naehe: kosinus(frage, v) });
-        }
-        aus.sort((a, b) => b.naehe - a.naehe);
-        return aus.slice(0, anzahl);
-    }
-}
-/**
- * Mischt zwei Rangfolgen über die PLATZIERUNG, nicht über die Punktzahl.
- *
- * Punktzahlen aus BM25 und aus einem Kosinus sind nicht vergleichbar: die eine
- * ist nach oben offen, die andere liegt zwischen -1 und 1. Wer sie addiert oder
- * skaliert, wählt unbeabsichtigt einen Gewinner und merkt es nie.
- *
- * Reciprocal Rank Fusion braucht keine gemeinsame Einheit.
- *
- * ── Wie viel Wortabgleich? ──────────────────────────────────────────────────
- *
- * Gemessen am 19.08.2026 an 499 Lektionen mit 100 Fragen:
- *
- *   Wortgewicht   Platz 1   Top 3   Top 10   MRR
- *   0,0 (nur Sinn)   40 %    60 %     68 %   51,4 %
- *   0,1              41 %    63 %     71 %   53,5 %
- *   0,2              42 %    57 %     70 %   52,0 %
- *   0,3              39 %    55 %     71 %   49,0 %
- *   0,4              38 %    51 %     69 %   47,7 %
- *   1,0 (nur Wörter) 21 %    33 %     47 %   29,3 %
- *
- * 0,1 ist auf drei von vier Maßen vorn und überall besser als reine Bedeutung.
- * Wenig Wortabgleich hilft, viel schadet: die Wörter fangen den Fall, in dem
- * jemand eine Fehlermeldung wörtlich einfügt, und stören sonst.
- *
- * Zu 0,2 ist der Abstand bei Platz 1 EINE Frage. Das ist kein Beleg, sondern
- * eine Richtung — wer hier dreht, misst nach.
- */
-export const WORT_GEWICHT = 0.1;
-export function mischeRangfolgen(woerter, bedeutung, wortGewicht = WORT_GEWICHT, k = 60) {
-    const punkte = new Map();
-    woerter.forEach((t, i) => punkte.set(t, (punkte.get(t) ?? 0) + wortGewicht / (k + i + 1)));
-    bedeutung.forEach((t, i) => punkte.set(t, (punkte.get(t) ?? 0) + (1 - wortGewicht) / (k + i + 1)));
-    return [...punkte.entries()].sort((a, b) => b[1] - a[1]).map(([t]) => t);
-}
-//# sourceMappingURL=bedeutung.js.map
+const x="cachly:lesson:vec:",y="cachly:lesson:vecname:";function b(o){return o.replace(/[:_-]+/g," ").replace(/\s+/g," ").trim()}const f=1,c=7;function d(o){let e=0;for(const t of o){const n=Math.abs(t);n>e&&(e=n)}const i=e>0?e/127:1;let r=c+o.length;for(;r%4!==1;)r++;const s=Buffer.alloc(r);s.writeUInt8(f,0),s.writeUInt16LE(o.length,1),s.writeFloatLE(i,3);for(let t=0;t<o.length;t++){const n=Math.round(o[t]/i);s.writeInt8(n>127?127:n<-127?-127:n,c+t)}return s.toString("base64")}function k(o){try{const e=Buffer.from(o,"base64");if(e.byteLength===0)return null;if(e[0]===f&&e.byteLength%4===1&&e.byteLength>c){const r=e.readUInt16LE(1);if(r===0||c+r>e.byteLength)return null;const s=e.readFloatLE(3);if(!Number.isFinite(s))return null;const t=new Array(r);for(let n=0;n<r;n++)t[n]=e.readInt8(c+n)*s;return t}if(e.byteLength%4!==0)return null;const i=new Float32Array(e.buffer,e.byteOffset,e.byteLength/4);return Array.from(i)}catch{return null}}function u(o,e){if(o.length!==e.length)return-1;let i=0,r=0,s=0;for(let t=0;t<o.length;t++)i+=o[t]*e[t],r+=o[t]*o[t],s+=e[t]*e[t];return r&&s?i/Math.sqrt(r*s):0}function E(o){const e=i=>typeof i=="string"?i:"";return[e(o.topic),e(o.what_worked),e(o.what_failed)].filter(Boolean).join(`
+`).slice(0,2e3)}class v{frischeMs;praefix;vektoren=new Map;geladen=0;constructor(e=6e4,i=x){this.frischeMs=e,this.praefix=i}naehe(e,i){const r=this.vektoren.get(`${this.praefix}${i}`);return r?u(e,r):-2}rohvektor(e){return this.vektoren.get(`${this.praefix}${e}`)??null}get groesse(){return this.vektoren.size}async aktualisiere(e,i=Date.now()){if(this.vektoren.size>0&&i-this.geladen<this.frischeMs)return;const r=[];let s="0";do{const[n,a]=await e.scan(s,"MATCH",`${this.praefix}*`,"COUNT",500);s=n,r.push(...a)}while(s!=="0");const t=r.filter(n=>!this.vektoren.has(n));for(let n=0;n<t.length;n+=100){const a=t.slice(n,n+100),g=await e.mget(...a);for(const[p,l]of g.entries()){if(!l)continue;const h=k(l);h&&this.vektoren.set(a[p],h)}}if(r.length<this.vektoren.size){const n=new Set(r);for(const a of[...this.vektoren.keys()])n.has(a)||this.vektoren.delete(a)}this.geladen=i}aehnlichste(e,i){const r=[];for(const[s,t]of this.vektoren)r.push({topic:s.slice(this.praefix.length),naehe:u(e,t)});return r.sort((s,t)=>t.naehe-s.naehe),r.slice(0,i)}}const w=.1;function L(o,e,i=w,r=60){const s=new Map;return o.forEach((t,n)=>s.set(t,(s.get(t)??0)+i/(r+n+1))),e.forEach((t,n)=>s.set(t,(s.get(t)??0)+(1-i)/(r+n+1))),[...s.entries()].sort((t,n)=>n[1]-t[1]).map(([t])=>t)}export{y as NAME_VEKTOR_PRAEFIX,x as VEKTOR_PRAEFIX,v as Vektorbestand,w as WORT_GEWICHT,k as entpacke,u as kosinus,L as mischeRangfolgen,d as packe,b as textFuerNamensVektor,E as textFuerVektor};