@cachly-dev/mcp-server 0.10.128 → 0.10.130

package/dist/src/raumkorrektur.js

@@ -1,197 +1 @@
-/**
- * Raumkorrektur: den Einbettungsraum brauchbar machen, bevor man darin sucht.
- *
- * ── Drei Übel, drei Gegenmittel ─────────────────────────────────────────────
- *
- * Ein Einbettungsraum ist nicht neutral. Er hat Eigenschaften, die das Sortieren
- * verderben — alle drei am 19.08.2026 an 499 echten Lektionen gemessen:
- *
- * 1. GEMEINSAME GRUNDRICHTUNG (Anisotropie). Ein durchschnittlicher Vektor
- *    zeigt zu 69,8 Prozent in Richtung des Schwerpunkts aller Vektoren. Dieser
- *    Anteil ist in JEDEM Vergleich derselbe und sagt daher nichts — er hebt nur
- *    alle Werte an und drückt die Unterschiede zusammen. Gemessen liegen alle
- *    Ähnlichkeiten zwischen 0,42 und 0,61.
- *
- * 2. RICHTUNGEN, DIE NUR SCHREIBSTIL SIND. Nach dem Schwerpunkt bleiben ein
- *    paar Hauptrichtungen übrig, die keine Bedeutung tragen, sondern Textsorte:
- *    "ist eine Fehlermeldung", "enthält Codeschnipsel", "ist auf Deutsch".
- *    Sie sind stark und lenken die Rangfolge.
- *
- * 3. NABEN. Manche Vektoren liegen einfach nahe an vielem. Sie erscheinen als
- *    Treffer für Fragen, mit denen sie nichts zu tun haben. Belegt: die Lektion
- *    `forge:arbeitskopie-nach-dem-merge-sofort-abraeumen` stand bei "Ich beende
- *    den Prozess, kurz darauf ist er neu da" UND bei "Wenn der Zwischenspeicher
- *    abläuft, schlagen alle Anfragen durch" auf Platz 1. Zwei Fragen ohne
- *    Berührungspunkt, dieselbe falsche Antwort.
- *
- * ── Die Gegenmittel ─────────────────────────────────────────────────────────
- *
- * Zu 1 und 2: Schwerpunkt abziehen und die stärksten verbleibenden
- * Hauptrichtungen entfernen. Was danach übrig bleibt, ist das, worin sich die
- * Texte inhaltlich unterscheiden.
- *
- * Zu 3: jedem Vektor seine eigene "Geselligkeit" ausrechnen — wie nah liegt er
- * im Mittel an seinen nächsten Nachbarn. Wer überall nah dran ist, bekommt
- * einen Abzug. Das ist die Idee hinter CSLS aus der Wortübersetzung, hier auf
- * den Fall übertragen, dass zur Bauzeit keine Fragen vorliegen: die Nachbarn
- * sind die anderen Lektionen.
- *
- * Entscheidend für den Betrieb: ALLES DAVON WIRD EINMAL AUSGERECHNET. Zur
- * Fragezeit bleibt ein Skalarprodukt und eine Subtraktion. Die Rangfolge wird
- * besser, ohne dass jemand länger wartet.
- */
-/** Skalarprodukt. */
-export function punktprodukt(a, b) {
-    let s = 0;
-    for (let i = 0; i < a.length; i++)
-        s += a[i] * b[i];
-    return s;
-}
-export function laenge(v) {
-    return Math.sqrt(punktprodukt(v, v));
-}
-/** Auf Länge 1 bringen. Ein Nullvektor bleibt, was er ist. */
-export function normiere(v) {
-    const l = laenge(v);
-    return l > 1e-12 ? v.map((x) => x / l) : v.slice();
-}
-/** Der Schwerpunkt — die gemeinsame Grundrichtung aller Vektoren. */
-export function schwerpunkt(vs) {
-    const d = vs[0]?.length ?? 0;
-    const m = new Array(d).fill(0);
-    for (const v of vs)
-        for (let i = 0; i < d; i++)
-            m[i] += v[i];
-    for (let i = 0; i < d; i++)
-        m[i] /= Math.max(1, vs.length);
-    return m;
-}
-/**
- * Die stärksten Hauptrichtungen, über Potenziteration mit Deflation.
- *
- * Warum von Hand statt einer Bibliothek: es sind rund zwanzig Zeilen, läuft
- * einmal, und eine Abhängigkeit für zwanzig Zeilen ist eine Abhängigkeit, die
- * jemand pflegen muss.
- *
- * Die Vektoren müssen bereits zentriert sein — sonst ist die erste
- * Hauptrichtung nur der Schwerpunkt, den wir gerade abgezogen haben.
- */
-export function hauptrichtungen(zentriert, anzahl, schritte = 30) {
-    const d = zentriert[0]?.length ?? 0;
-    const rest = zentriert.map((v) => v.slice());
-    const aus = [];
-    for (let k = 0; k < anzahl; k++) {
-        // Startvektor: fest, nicht zufällig — sonst liefert derselbe Bestand bei
-        // jedem Lauf leicht andere Richtungen, und niemand kann eine Messung
-        // wiederholen.
-        let u = new Array(d).fill(0).map((_, i) => Math.sin(i * (k + 1) * 0.7));
-        u = normiere(u);
-        for (let s = 0; s < schritte; s++) {
-            const neu = new Array(d).fill(0);
-            for (const v of rest) {
-                const p = punktprodukt(v, u);
-                for (let i = 0; i < d; i++)
-                    neu[i] += p * v[i];
-            }
-            const l = laenge(neu);
-            if (l < 1e-12)
-                break;
-            for (let i = 0; i < d; i++)
-                neu[i] /= l;
-            u = neu;
-        }
-        aus.push(u);
-        // Deflation: den gefundenen Anteil aus allen Vektoren entfernen, damit die
-        // nächste Iteration eine ANDERE Richtung findet.
-        for (const v of rest) {
-            const p = punktprodukt(v, u);
-            for (let i = 0; i < d; i++)
-                v[i] -= p * u[i];
-        }
-    }
-    return aus;
-}
-/** Was von einem Vektor bleibt, wenn Schwerpunkt und Hauptrichtungen weg sind. */
-export function bereinige(v, mitte, richtungen) {
-    const w = v.map((x, i) => x - mitte[i]);
-    for (const u of richtungen) {
-        const p = punktprodukt(w, u);
-        for (let i = 0; i < w.length; i++)
-            w[i] -= p * u[i];
-    }
-    return normiere(w);
-}
-/**
- * Die "Geselligkeit" jedes Vektors: mittlere Ähnlichkeit zu seinen k nächsten
- * Nachbarn im selben Bestand.
- *
- * Ein hoher Wert heißt: dieser Vektor liegt in einer dichten Gegend und ist
- * vielem nah. Solche Naben erscheinen als Treffer für Fragen, mit denen sie
- * nichts zu tun haben — nicht weil sie passen, sondern weil sie überall
- * passen.
- *
- * Der Wert wird EINMAL berechnet und beim Suchen abgezogen. Kosten zur
- * Fragezeit: eine Subtraktion.
- */
-export function geselligkeit(normierte, k = 10) {
-    const n = normierte.length;
-    const aus = new Array(n).fill(0);
-    for (let i = 0; i < n; i++) {
-        // Die k besten Ähnlichkeiten sammeln, ohne alles zu sortieren.
-        const beste = [];
-        for (let j = 0; j < n; j++) {
-            if (i === j)
-                continue;
-            const s = punktprodukt(normierte[i], normierte[j]);
-            if (beste.length < k) {
-                beste.push(s);
-                if (beste.length === k)
-                    beste.sort((a, b) => a - b);
-            }
-            else if (s > beste[0]) {
-                beste[0] = s;
-                beste.sort((a, b) => a - b);
-            }
-        }
-        aus[i] = beste.length ? beste.reduce((a, b) => a + b, 0) / beste.length : 0;
-    }
-    return aus;
-}
-export function baueRaum(roh, optionen = {}) {
-    const anzahlRichtungen = optionen.richtungen ?? 3;
-    const nachbarn = optionen.nachbarn ?? 10;
-    const beta = optionen.beta ?? 0.5;
-    const da = roh.filter(Boolean);
-    const mitte = schwerpunkt(da);
-    const zentriert = da.map((v) => v.map((x, i) => x - mitte[i]));
-    const richtungen = anzahlRichtungen > 0 ? hauptrichtungen(zentriert, anzahlRichtungen) : [];
-    // Bereinigte Vektoren in der ursprünglichen Reihenfolge — Lücken bleiben
-    // Lücken, damit ein fehlender Vektor nicht still zu einem Nullvektor wird,
-    // der zu allem gleich weit entfernt ist.
-    const vektoren = [];
-    const gueltigeIndizes = [];
-    for (const [i, v] of roh.entries()) {
-        if (!v) {
-            vektoren.push([]);
-            continue;
-        }
-        vektoren.push(bereinige(v, mitte, richtungen));
-        gueltigeIndizes.push(i);
-    }
-    const abzug = new Array(roh.length).fill(0);
-    const nurGueltige = gueltigeIndizes.map((i) => vektoren[i]);
-    const g = geselligkeit(nurGueltige, nachbarn);
-    gueltigeIndizes.forEach((idx, k) => { abzug[idx] = g[k]; });
-    return { mitte, richtungen, vektoren, abzug, beta };
-}
-/**
- * Bewertet eine Frage gegen alle Lektionen des Raums.
- *
- * `2 * cos - abzug` ist die Form aus CSLS. Der Faktor 2 sorgt dafür, dass der
- * Abzug die Ähnlichkeit dämpft und nicht überstimmt.
- */
-export function bewerteImRaum(raum, frage) {
-    const f = bereinige(frage, raum.mitte, raum.richtungen);
-    return raum.vektoren.map((v, i) => v.length === 0 ? -2 : 2 * punktprodukt(f, v) - raum.beta * raum.abzug[i]);
-}
-//# sourceMappingURL=raumkorrektur.js.map
+function b(t,o){let r=0;for(let n=0;n<t.length;n++)r+=t[n]*o[n];return r}function x(t){return Math.sqrt(b(t,t))}function w(t){const o=x(t);return o>1e-12?t.map(r=>r/o):t.slice()}function y(t){const o=t[0]?.length??0,r=new Array(o).fill(0);for(const n of t)for(let e=0;e<o;e++)r[e]+=n[e];for(let n=0;n<o;n++)r[n]/=Math.max(1,t.length);return r}function A(t,o,r=30){const n=t[0]?.length??0,e=t.map(c=>c.slice()),s=[];for(let c=0;c<o;c++){let i=new Array(n).fill(0).map((f,l)=>Math.sin(l*(c+1)*.7));i=w(i);for(let f=0;f<r;f++){const l=new Array(n).fill(0);for(const a of e){const m=b(a,i);for(let g=0;g<n;g++)l[g]+=m*a[g]}const u=x(l);if(u<1e-12)break;for(let a=0;a<n;a++)l[a]/=u;i=l}s.push(i);for(const f of e){const l=b(f,i);for(let u=0;u<n;u++)f[u]-=l*i[u]}}return s}function k(t,o,r){const n=t.map((e,s)=>e-o[s]);for(const e of r){const s=b(n,e);for(let c=0;c<n.length;c++)n[c]-=s*e[c]}return w(n)}function z(t,o=10){const r=t.length,n=new Array(r).fill(0);for(let e=0;e<r;e++){const s=[];for(let c=0;c<r;c++){if(e===c)continue;const i=b(t[e],t[c]);s.length<o?(s.push(i),s.length===o&&s.sort((f,l)=>f-l)):i>s[0]&&(s[0]=i,s.sort((f,l)=>f-l))}n[e]=s.length?s.reduce((c,i)=>c+i,0)/s.length:0}return n}function M(t,o={}){const r=o.richtungen??3,n=o.nachbarn??10,e=o.beta??.5,s=t.filter(Boolean),c=y(s),i=s.map(h=>h.map((p,d)=>p-c[d])),f=r>0?A(i,r):[],l=[],u=[];for(const[h,p]of t.entries()){if(!p){l.push([]);continue}l.push(k(p,c,f)),u.push(h)}const a=new Array(t.length).fill(0),m=u.map(h=>l[h]),g=z(m,n);return u.forEach((h,p)=>{a[h]=g[p]}),{mitte:c,richtungen:f,vektoren:l,abzug:a,beta:e}}function R(t,o){const r=k(o,t.mitte,t.richtungen);return t.vektoren.map((n,e)=>n.length===0?-2:2*b(r,n)-t.beta*t.abzug[e])}export{M as baueRaum,k as bereinige,R as bewerteImRaum,z as geselligkeit,A as hauptrichtungen,x as laenge,w as normiere,b as punktprodukt,y as schwerpunkt};

package/dist/src/recall-tiefe.js

@@ -1,42 +1 @@
-/**
- * Wie viele Treffer zeigt `smart_recall` — und wie viele haelt es zurueck?
- *
- * Eigenes Modul, weil hier ein Versprechen eingeloest wird, das vorher nur im
- * Kommentar stand. Der Kommentar am Teaser-Gate sagte seit jeher:
- *
- *   "the magic moment is sacred ... never an access wall: the #1 result is
- *    always returned"
- *
- * Der Code sagte `visibleCount = gateActive ? 0 : 8` — also NULL Treffer,
- * sobald ein Frei-Konto sein Monatskontingent ueberschritten hat. Der Nutzer
- * las die Ueberschrift "Results (23 — hybrid)", darunter keine einzige Zeile
- * und dann eine Kaufaufforderung. Das sieht nicht aus wie eine Rechnung,
- * sondern wie ein kaputtes Werkzeug — besonders bei Ambient Recall, das bei
- * jedem Prompt feuert und das Kontingent in Tagen aufbraucht.
- *
- * Fehlerklasse: eine Zusage an zwei Orten gepflegt (Kommentar und Zweig).
- * Deshalb ist die Regel jetzt eine Funktion mit Tests, nicht ein Satz Prosa.
- */
-/** Der eine Treffer, den auch ein ueberzogenes Frei-Konto immer sieht. */
-export const TIEFE_UEBER_LIMIT = 1;
-/** Volle Tiefe bei einer einzelnen Frage. */
-export const TIEFE_VOLL = 8;
-/** Volle Tiefe, wenn die Frage in Unterfragen zerfaellt (mehr Themen, mehr Platz). */
-export const TIEFE_VOLL_MEHRTHEMIG = 12;
-/**
- * Nie eine Mauer, immer eine Bremse: ueber dem Limit bleibt genau der beste
- * Treffer sichtbar, der Rest wird gezaehlt und benannt.
- *
- * Bei null Treffern gibt es nichts zu zeigen und nichts zurueckzuhalten — ein
- * leeres Ergebnis darf nie als "hinter der Bezahlschranke" erscheinen, sonst
- * verkauft die Meldung etwas, das gar nicht existiert.
- */
-export function recallTiefe({ ueberLimit, gesamt, volleTiefe = TIEFE_VOLL }) {
-    const vorhanden = Number.isFinite(gesamt) && gesamt > 0 ? Math.floor(gesamt) : 0;
-    if (vorhanden === 0)
-        return { sichtbar: 0, zurueckgehalten: 0 };
-    const obergrenze = ueberLimit ? TIEFE_UEBER_LIMIT : Math.max(0, Math.floor(volleTiefe));
-    const sichtbar = Math.min(vorhanden, obergrenze);
-    return { sichtbar, zurueckgehalten: ueberLimit ? vorhanden - sichtbar : 0 };
-}
-//# sourceMappingURL=recall-tiefe.js.map
+const c=1,I=8,a=12;function h({ueberLimit:e,gesamt:t,volleTiefe:o=8}){const r=Number.isFinite(t)&&t>0?Math.floor(t):0;if(r===0)return{sichtbar:0,zurueckgehalten:0};const E=e?1:Math.max(0,Math.floor(o)),n=Math.min(r,E);return{sichtbar:n,zurueckgehalten:e?r-n:0}}export{c as TIEFE_UEBER_LIMIT,I as TIEFE_VOLL,a as TIEFE_VOLL_MEHRTHEMIG,h as recallTiefe};

package/dist/src/rerank.js

@@ -1,154 +1 @@
-/**
- * Quality-aware reranking for Brain recall.
- *
- * The raw BM25+ keyword search (src/search.ts) ranks purely by *textual* relevance.
- * That is necessary but not sufficient: when an agent asks "how do I fix the flaky
- * deploy?", a *failed* attempt with similar words can out-rank the *proven success*
- * lesson that actually solves it. Anthropic's flat-file memory has exactly this
- * problem — it reads files in order, with no notion of which lesson is trustworthy.
- *
- * This module is Cachly's structural advantage made concrete: we re-rank text
- * matches by the *quality* of the underlying lesson — outcome, confidence,
- * proven-ness (recall_count), severity and human review (endorsements) — so the
- * lesson most likely to help surfaces first. A flat-file memory has none of these
- * signals; a senior-confirmed, ten-times-recalled success reads identically to a
- * one-off failed attempt.
- *
- * It is intentionally pure (no I/O): the lesson JSON already travels inside each
- * KeywordMatch.content for `cachly:lesson:best:*` keys, so reranking needs no extra
- * Redis round-trips. This keeps it fast and trivially benchmarkable (see
- * src/bench/cachly-bench.ts).
- */
-import { safeJsonParse } from './utils.js';
-// ── Tunable weights (kept conservative; validated by Cachly-Bench) ─────────────
-const OUTCOME_WEIGHT = {
-    success: 1.0,
-    partial: 0.8,
-    failure: 0.55,
-};
-const OUTCOME_DEFAULT = 0.75; // unknown / not a lesson with an outcome
-const SEVERITY_WEIGHT = {
-    critical: 1.15,
-    major: 1.05,
-    minor: 1.0,
-};
-const SEVERITY_DEFAULT = 1.0;
-// Governance: a human-confirmed lesson is more trustworthy than one proven only
-// by automated recall. A senior review weighs more than a peer review; multiple
-// endorsements add a small, saturating bump on top.
-const REVIEW_LEVEL_WEIGHT = {
-    senior: 1.25,
-    peer: 1.1,
-};
-// Clamp so a strong text match is never fully buried by quality, and a weak text
-// match is never catapulted to the top purely on quality.
-// MAX lowered 2.5→1.8: on larger corpora a high-quality but weakly-matching lesson
-// could overtake a strongly-matching relevant one and push it out of the top-k.
-// 1.8 keeps the home-corpus Precision@1 lift while improving external-corpus
-// Precision@1 + MRR (validated by src/bench/external-corpus.ts).
-const MIN_MULTIPLIER = 0.5;
-const MAX_MULTIPLIER = 1.8;
-const LESSON_KEY_PREFIX = 'cachly:lesson:best:';
-/**
- * Compute the quality multiplier for a single lesson.
- * Returns 1.0 (neutral) for documents that carry no quality signal (e.g. context).
- */
-export function qualityMultiplier(lesson) {
-    if (!lesson || (lesson.outcome === undefined && lesson.confidence === undefined
-        && lesson.recall_count === undefined && lesson.reviewed_by === undefined
-        && lesson.endorsements === undefined)) {
-        return 1.0;
-    }
-    // 1. Outcome — a proven success is what the agent actually wants.
-    const outcome = OUTCOME_WEIGHT[lesson.outcome ?? ''] ?? OUTCOME_DEFAULT;
-    // 2. Confidence — maps 0..1 → 0.7..1.3 so it nudges, not dominates.
-    const conf = typeof lesson.confidence === 'number' ? Math.max(0, Math.min(1, lesson.confidence)) : 0.6;
-    const confidenceFactor = 0.7 + 0.6 * conf;
-    // 3. Proven-ness — a lesson recalled many times has stood the test of use.
-    //    Log-scaled so it saturates: rc=0→1.0, rc=5→~1.18, rc=50→~1.30.
-    const rc = Math.max(0, lesson.recall_count ?? 0);
-    const provenBoost = 1 + Math.min(0.3, Math.log1p(rc) / 13);
-    // 4. Severity — when two lessons tie, surface the one guarding the worse failure.
-    const severity = SEVERITY_WEIGHT[lesson.severity ?? ''] ?? SEVERITY_DEFAULT;
-    // 5. Governance — a human-confirmed lesson outranks an unreviewed one.
-    //    Base weight from the review level, plus a small saturating bump for
-    //    additional endorsements (rc-style log curve, capped at +0.1).
-    const reviewBase = lesson.reviewed_by
-        ? (REVIEW_LEVEL_WEIGHT[lesson.review_level ?? 'peer'] ?? REVIEW_LEVEL_WEIGHT.peer)
-        : 1.0;
-    const extraEndorse = Math.max(0, (lesson.endorsements ?? 0) - 1);
-    const reviewBoost = reviewBase * (1 + Math.min(0.1, Math.log1p(extraEndorse) / 20));
-    const m = outcome * confidenceFactor * provenBoost * severity * reviewBoost;
-    return Math.max(MIN_MULTIPLIER, Math.min(MAX_MULTIPLIER, m));
-}
-/** Extract the quality signal from a match, if its content is a stored lesson. */
-export function extractLessonQuality(match) {
-    if (!match.key.startsWith(LESSON_KEY_PREFIX))
-        return null;
-    return safeJsonParse(match.content, null);
-}
-/**
- * Rerank BM25 keyword matches by lesson quality.
- *
- * BM25 scores are compressed with a 0.3-power root before quality is applied.
- * Compression is the key: a distractor lesson whose `what_failed` contains the
- * exact query phrase can score 5–6× higher in BM25 than the correct success lesson.
- * A linear quality multiplier of ±40% cannot overcome that gap; after ^0.3
- * compression the ratio shrinks to ~1.5×, well within the quality range.
- *
- * The formula  compressed_score * (0.4 + 0.6 * boost)  gives quality 60% weight
- * on the compressed axis. A failure lesson (boost ≈ 0.5) retains 70% of its
- * compressed score; a senior-confirmed success (boost ≈ 1.8) gets 148%.
- * Ties are broken by the raw BM25 score (stable, deterministic).
- */
-/**
- * Wie stark Qualitaetsmerkmale die Rangfolge bewegen duerfen.
- *
- * Bleibt bei 0.6 — dem Wert von vorher. Die Messreihe vom 19.08.2026 zeigt,
- * dass dieser Wert auf echten Daten NICHTS kostet: bei ungestauchter Relevanz
- * liefern 0.6, 0.3 und 0.15 dasselbe Ergebnis (30 Prozent auf Platz 1).
- *
- * Das ist der Grund, hier nichts zu aendern. Der Schaden kam allein von der
- * Stauchung darunter. Wer zwei Dinge gleichzeitig verstellt, weiss hinterher
- * nicht, welches gewirkt hat.
- */
-const QUALITAETS_GEWICHT = 0.6;
-export function rerankByQuality(matches) {
-    if (matches.length === 0)
-        return [];
-    const reranked = matches.map(m => {
-        // ── Die Relevanz wird NICHT mehr plattgedrueckt ─────────────────────────
-        //
-        // Hier stand `Math.pow(score, 0.3)`. Das war Absicht: die Relevanz wurde
-        // zusammengestaucht, damit die Qualitaetsmerkmale (Zuversicht, Abnahme,
-        // Zustimmungen) die Rangfolge mitbestimmen koennen. Aus einem
-        // zehnfachen Relevanzvorsprung wurde ein doppelter.
-        //
-        // Auf dem Pruefstand mit 17 Lektionen war das ein Gewinn: 92,3 statt
-        // 69,2 Prozent. Genau diese Zahl steht seit Monaten auf der Landingpage.
-        //
-        // Auf 498 echten Lektionen, am 19.08.2026 gemessen, ist es der Verlust:
-        //
-        //   Stauchung   echter Bestand   Pruefstand
-        //   ^0.3            15 %            92,3 %
-        //   ^0.6            25 %            76,9 %
-        //   ^1.0 (keine)    30 %            69,2 %
-        //
-        // Der gesamte gemessene Vorteil auf dem Pruefstand IST der Schaden auf
-        // echten Daten. Bei 17 Lektionen ist der richtige Treffer so eindeutig,
-        // dass er auch gestaucht gewinnt. Bei 498 ist die Relevanz das knappe
-        // Gut, und wer sie staucht, wirft weg, was er hat.
-        const compressed = Math.max(0, m.score);
-        const lesson = extractLessonQuality(m);
-        const boost = qualityMultiplier(lesson);
-        // Qualitaet wirkt unveraendert auf die UNGESTAUCHTE Relevanz. Damit kann
-        // sie einen knappen Textvorsprung noch drehen (eine belegte Loesung schlaegt
-        // einen etwas besser passenden Fehlversuch), einen deutlichen aber nicht
-        // mehr.
-        const finalScore = compressed * (1 - QUALITAETS_GEWICHT + QUALITAETS_GEWICHT * boost);
-        return { ...m, finalScore, qualityBoost: boost };
-    });
-    reranked.sort((a, b) => (b.finalScore - a.finalScore) || (b.score - a.score));
-    return reranked;
-}
-//# sourceMappingURL=rerank.js.map
+import{safeJsonParse as m}from"./utils.js";const M={success:1,partial:.8,failure:.55},_=.75,l={critical:1.15,major:1.05,minor:1},p=1,a={senior:1.25,peer:1.1},I=.5,T=1.8,h="cachly:lesson:best:";function y(e){if(!e||e.outcome===void 0&&e.confidence===void 0&&e.recall_count===void 0&&e.reviewed_by===void 0&&e.endorsements===void 0)return 1;const o=M[e.outcome??""]??_,n=.7+.6*(typeof e.confidence=="number"?Math.max(0,Math.min(1,e.confidence)):.6),c=Math.max(0,e.recall_count??0),r=1+Math.min(.3,Math.log1p(c)/13),i=l[e.severity??""]??p,u=e.reviewed_by?a[e.review_level??"peer"]??a.peer:1,f=Math.max(0,(e.endorsements??0)-1),E=u*(1+Math.min(.1,Math.log1p(f)/20)),d=o*n*r*i*E;return Math.max(I,Math.min(T,d))}function L(e){return e.key.startsWith(h)?m(e.content,null):null}const s=.6;function v(e){if(e.length===0)return[];const o=e.map(t=>{const n=Math.max(0,t.score),c=L(t),r=y(c),i=n*(1-s+s*r);return{...t,finalScore:i,qualityBoost:r}});return o.sort((t,n)=>n.finalScore-t.finalScore||n.score-t.score),o}export{L as extractLessonQuality,y as qualityMultiplier,v as rerankByQuality};

package/dist/src/resonanz.js

@@ -0,0 +1 @@
+import{packe as g,entpacke as k,kosinus as p}from"./bedeutung.js";const a="cachly:lesson:res:";function v(s,e,t=.3){if(!s||s.length!==e.length)return f(e);const n=s.map((r,o)=>(1-t)*r+t*e[o]);return f(n)}function f(s){let e=0;for(const n of s)e+=n*n;const t=Math.sqrt(e);return t>0?s.map(n=>n/t):s}class M{frischeMs;vektoren=new Map;geladen=0;constructor(e=6e4){this.frischeMs=e}naehe(e,t){const n=this.vektoren.get(t);return n?p(e,n):-2}get groesse(){return this.vektoren.size}setzeDirekt(e,t){this.vektoren.set(e,t)}async aktualisiere(e,t=Date.now()){if(this.vektoren.size>0&&t-this.geladen<this.frischeMs)return;const n=[];let r="0";do{const[c,i]=await e.scan(r,"MATCH",`${a}*`,"COUNT",500);r=c,n.push(...i)}while(r!=="0");if(n.length===0){this.geladen=t;return}const o=await e.mget(...n),h=new Map;for(const[c,i]of n.entries()){const u=o[c];if(!u)continue;const l=k(u);l&&h.set(i.slice(a.length),l)}this.vektoren=h,this.geladen=t}async schreibe(e,t,n,r=.3){try{const o=v(this.vektoren.get(t)??null,n,r);return this.vektoren.set(t,o),await e.set(`${a}${t}`,g(o)),!0}catch{return!1}}}export{a as RESONANZ_PRAEFIX,M as Resonanzbestand,f as normiere,v as ueberlagere};