@cachly-dev/mcp-server 0.10.129 → 0.10.130

package/dist/src/wartung/vektoren-verdichten.js

@@ -1,200 +1 @@
-/**
- * Vektoren von float32 auf int8 umschreiben — der Umzug, den `packe` braucht.
- *
- * ── Warum es das gibt ───────────────────────────────────────────────────────
- *
- * Am 20.08.2026 belegte ein Bestand mit 524 Lektionen 23,6 MB von 25 MB
- * Tarifgrenze — 94 %. Davon waren 11,2 MB Vektoren: 6,0 MB Volltext und Namen,
- * 5,2 MB Eingänge. Die nächste Lektion wäre an einem Schreibfehler gescheitert.
- *
- * `packe` schreibt seither int8 statt float32 (Faktor 3,96). Neu geschriebene
- * Lektionen sind damit klein. Die BESTEHENDEN bleiben groß, bis sie einmal neu
- * gelernt werden — und die meisten werden nie neu gelernt. Dieses Werkzeug
- * holt sie ein.
- *
- * ── Was es tut, und in welcher Reihenfolge ─────────────────────────────────
- *
- * 1. Sichern: jeder betroffene Schlüssel wird VORHER in eine Datei geschrieben.
- * 2. Prüfen: die Sicherung wird zurückgelesen und muss vollständig sein.
- * 3. Umschreiben: erst danach wird der Speicher angefasst.
- *
- * Ohne Schritt 2 wäre die Sicherung eine Behauptung. Eine Sicherung, die nie
- * zurückgelesen wurde, ist keine.
- *
- * Aufruf:
- *   REDIS_URL=... npx tsx src/wartung/vektoren-verdichten.ts --sicherung <datei>
- *   REDIS_URL=... npx tsx src/wartung/vektoren-verdichten.ts --sicherung <datei> --schreiben
- *   REDIS_URL=... npx tsx src/wartung/vektoren-verdichten.ts --sicherung <datei> --zurueck
- *
- * Ohne `--schreiben` wird nur gerechnet und gemeldet. Das ist Absicht: der
- * Trockenlauf ist der Normalfall, das Schreiben ist der Sonderfall.
- */
-import { readFileSync, writeFileSync, existsSync } from 'node:fs';
-import { Redis } from 'ioredis';
-import { packe, entpacke } from '../bedeutung.js';
-/** Alle Schlüssel zu einem Muster, ohne KEYS (das blockiert den Server). */
-export async function alleSchluessel(redis, muster) {
-    const aus = [];
-    let cursor = '0';
-    do {
-        const [next, gefunden] = await redis.scan(cursor, 'MATCH', muster, 'COUNT', 500);
-        cursor = next;
-        aus.push(...gefunden);
-    } while (cursor !== '0');
-    return aus;
-}
-/**
- * Ist dieser Wert schon im neuen Format?
- *
- * Wird gebraucht, damit ein zweiter Lauf nichts kaputt macht und nichts doppelt
- * zählt. Ein Umzug, der nur einmal laufen darf, ist ein Umzug mit einer Falle.
- */
-export function istInt8(base64) {
-    const b = Buffer.from(base64, 'base64');
-    return b.byteLength > 7 && b[0] === 0x01 && b.byteLength % 4 === 1;
-}
-/** Rechnet aus, was der Umzug bringt — und schreibt nur, wenn `schreiben` gesetzt ist. */
-export async function verdichte(redis, schreiben) {
-    const b = { schluessel: 0, felder: 0, vorher: 0, nachher: 0, uebersprungen: 0 };
-    // Einfache Werte: Volltext- und Namensvektoren.
-    for (const muster of ['cachly:lesson:vec:*', 'cachly:lesson:vecname:*']) {
-        for (const k of await alleSchluessel(redis, muster)) {
-            const roh = await redis.get(k);
-            if (!roh)
-                continue;
-            b.schluessel++;
-            if (istInt8(roh)) {
-                b.uebersprungen++;
-                b.vorher += roh.length;
-                b.nachher += roh.length;
-                continue;
-            }
-            const v = entpacke(roh);
-            if (!v) {
-                b.uebersprungen++;
-                continue;
-            }
-            const neu = packe(v);
-            b.vorher += roh.length;
-            b.nachher += neu.length;
-            b.felder++;
-            if (schreiben)
-                await redis.set(k, neu);
-        }
-    }
-    // Eingänge: ein Hash je Lektion, ein Vektor je Feld.
-    for (const k of await alleSchluessel(redis, 'cachly:lesson:eing:*')) {
-        const h = await redis.hgetall(k);
-        const felder = [];
-        b.schluessel++;
-        for (const [feld, roh] of Object.entries(h)) {
-            if (istInt8(roh)) {
-                b.uebersprungen++;
-                b.vorher += roh.length;
-                b.nachher += roh.length;
-                continue;
-            }
-            const v = entpacke(roh);
-            if (!v) {
-                b.uebersprungen++;
-                continue;
-            }
-            const neu = packe(v);
-            b.vorher += roh.length;
-            b.nachher += neu.length;
-            b.felder++;
-            felder.push(feld, neu);
-        }
-        if (schreiben && felder.length > 0)
-            await redis.hset(k, ...felder);
-    }
-    return b;
-}
-const mb = (zeichen) => `${(zeichen / 1024 / 1024).toFixed(2)} MB`;
-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;
-    if (!url) {
-        console.error('NICHT GELAUFEN: REDIS_URL fehlt.');
-        process.exit(2);
-    }
-    const sicherungsPfad = flag('sicherung');
-    if (!sicherungsPfad) {
-        console.error('NICHT GELAUFEN: --sicherung <datei> fehlt.');
-        process.exit(2);
-    }
-    const schreiben = argv.includes('--schreiben');
-    const zurueck = argv.includes('--zurueck');
-    const redis = new Redis(url, { maxRetriesPerRequest: 2, connectTimeout: 8000 });
-    try {
-        if (zurueck) {
-            if (!existsSync(sicherungsPfad)) {
-                console.error(`NICHT GELAUFEN: Sicherung fehlt (${sicherungsPfad}).`);
-                process.exit(2);
-            }
-            const s = JSON.parse(readFileSync(sicherungsPfad, 'utf8'));
-            let n = 0;
-            for (const [k, v] of Object.entries(s.werte)) {
-                await redis.set(k, v);
-                n++;
-            }
-            for (const [k, h] of Object.entries(s.hashes)) {
-                const felder = Object.entries(h).flat();
-                if (felder.length === 0)
-                    continue;
-                await redis.del(k);
-                await redis.hset(k, ...felder);
-                n++;
-            }
-            console.log(`ZURUECKGESPIELT: ${n} Schluessel aus ${sicherungsPfad}`);
-            return;
-        }
-        // 1. Sichern — immer, auch im Trockenlauf.
-        const werte = {};
-        const hashes = {};
-        for (const muster of ['cachly:lesson:vec:*', 'cachly:lesson:vecname:*']) {
-            for (const k of await alleSchluessel(redis, muster)) {
-                const roh = await redis.get(k);
-                if (roh)
-                    werte[k] = roh;
-            }
-        }
-        for (const k of await alleSchluessel(redis, 'cachly:lesson:eing:*')) {
-            hashes[k] = await redis.hgetall(k);
-        }
-        writeFileSync(sicherungsPfad, JSON.stringify({ werte, hashes }), { encoding: 'utf8' });
-        // 2. Sicherung zurueckLESEN und pruefen. Ungeprueft ist sie keine.
-        const probe = JSON.parse(readFileSync(sicherungsPfad, 'utf8'));
-        const wSoll = Object.keys(werte).length;
-        const wIst = Object.keys(probe.werte).length;
-        const hSoll = Object.keys(hashes).length;
-        const hIst = Object.keys(probe.hashes).length;
-        if (wSoll !== wIst || hSoll !== hIst || wSoll === 0) {
-            console.error(`ABBRUCH: Sicherung unvollstaendig (${wIst}/${wSoll} Werte, ${hIst}/${hSoll} Hashes).`);
-            process.exit(3);
-        }
-        console.log(`Sicherung geprueft: ${wIst} Werte + ${hIst} Hashes in ${sicherungsPfad}`);
-        // 3. Erst jetzt rechnen bzw. schreiben.
-        const b = await verdichte(redis, schreiben);
-        console.log('');
-        console.log(`  Schluessel angesehen  : ${b.schluessel}`);
-        console.log(`  Vektoren umgeschrieben: ${b.felder}`);
-        console.log(`  uebersprungen         : ${b.uebersprungen} (schon int8 oder unlesbar)`);
-        console.log(`  vorher                : ${mb(b.vorher)}`);
-        console.log(`  nachher               : ${mb(b.nachher)}`);
-        console.log(`  gespart               : ${mb(b.vorher - b.nachher)}  (Faktor ${(b.vorher / Math.max(1, b.nachher)).toFixed(2)})`);
-        console.log('');
-        console.log(schreiben ? '  GESCHRIEBEN.' : '  TROCKENLAUF — nichts veraendert. Mit --schreiben ausfuehren.');
-    }
-    finally {
-        redis.disconnect();
-    }
-}
-const direktGestartet = process.argv[1]?.replace(/\\/g, '/').endsWith('/vektoren-verdichten.ts');
-if (direktGestartet)
-    main().catch((e) => { console.error('FEHLER:', e); process.exit(1); });
-//# sourceMappingURL=vektoren-verdichten.js.map
+import{readFileSync as k,writeFileSync as O,existsSync as R}from"node:fs";import{Redis as L}from"ioredis";import{packe as E,entpacke as m}from"../bedeutung.js";async function p(n,r){const e=[];let s="0";do{const[l,t]=await n.scan(s,"MATCH",r,"COUNT",500);s=l,e.push(...t)}while(s!=="0");return e}function x(n){const r=Buffer.from(n,"base64");return r.byteLength>7&&r[0]===1&&r.byteLength%4===1}async function N(n,r){const e={schluessel:0,felder:0,vorher:0,nachher:0,uebersprungen:0};for(const s of["cachly:lesson:vec:*","cachly:lesson:vecname:*"])for(const l of await p(n,s)){const t=await n.get(l);if(!t)continue;if(e.schluessel++,x(t)){e.uebersprungen++,e.vorher+=t.length,e.nachher+=t.length;continue}const o=m(t);if(!o){e.uebersprungen++;continue}const c=E(o);e.vorher+=t.length,e.nachher+=c.length,e.felder++,r&&await n.set(l,c)}for(const s of await p(n,"cachly:lesson:eing:*")){const l=await n.hgetall(s),t=[];e.schluessel++;for(const[o,c]of Object.entries(l)){if(x(c)){e.uebersprungen++,e.vorher+=c.length,e.nachher+=c.length;continue}const h=m(c);if(!h){e.uebersprungen++;continue}const g=E(h);e.vorher+=c.length,e.nachher+=g.length,e.felder++,t.push(o,g)}r&&t.length>0&&await n.hset(s,...t)}return e}const y=n=>`${(n/1024/1024).toFixed(2)} MB`;async function C(){const n=process.argv.slice(2),r=c=>{const h=n.indexOf(`--${c}`);return h!==-1?n[h+1]:void 0},e=process.env.CACHLY_REDIS_URL??process.env.REDIS_URL;e||(console.error("NICHT GELAUFEN: REDIS_URL fehlt."),process.exit(2));const s=r("sicherung");s||(console.error("NICHT GELAUFEN: --sicherung <datei> fehlt."),process.exit(2));const l=n.includes("--schreiben"),t=n.includes("--zurueck"),o=new L(e,{maxRetriesPerRequest:2,connectTimeout:8e3});try{if(t){R(s)||(console.error(`NICHT GELAUFEN: Sicherung fehlt (${s}).`),process.exit(2));const a=JSON.parse(k(s,"utf8"));let f=0;for(const[u,w]of Object.entries(a.werte))await o.set(u,w),f++;for(const[u,w]of Object.entries(a.hashes)){const $=Object.entries(w).flat();$.length!==0&&(await o.del(u),await o.hset(u,...$),f++)}console.log(`ZURUECKGESPIELT: ${f} Schluessel aus ${s}`);return}const c={},h={};for(const a of["cachly:lesson:vec:*","cachly:lesson:vecname:*"])for(const f of await p(o,a)){const u=await o.get(f);u&&(c[f]=u)}for(const a of await p(o,"cachly:lesson:eing:*"))h[a]=await o.hgetall(a);O(s,JSON.stringify({werte:c,hashes:h}),{encoding:"utf8"});const g=JSON.parse(k(s,"utf8")),b=Object.keys(c).length,d=Object.keys(g.werte).length,S=Object.keys(h).length,v=Object.keys(g.hashes).length;(b!==d||S!==v||b===0)&&(console.error(`ABBRUCH: Sicherung unvollstaendig (${d}/${b} Werte, ${v}/${S} Hashes).`),process.exit(3)),console.log(`Sicherung geprueft: ${d} Werte + ${v} Hashes in ${s}`);const i=await N(o,l);console.log(""),console.log(`  Schluessel angesehen  : ${i.schluessel}`),console.log(`  Vektoren umgeschrieben: ${i.felder}`),console.log(`  uebersprungen         : ${i.uebersprungen} (schon int8 oder unlesbar)`),console.log(`  vorher                : ${y(i.vorher)}`),console.log(`  nachher               : ${y(i.nachher)}`),console.log(`  gespart               : ${y(i.vorher-i.nachher)}  (Faktor ${(i.vorher/Math.max(1,i.nachher)).toFixed(2)})`),console.log(""),console.log(l?"  GESCHRIEBEN.":"  TROCKENLAUF \u2014 nichts veraendert. Mit --schreiben ausfuehren.")}finally{o.disconnect()}}const I=process.argv[1]?.replace(/\\/g,"/").endsWith("/vektoren-verdichten.ts");I&&C().catch(n=>{console.error("FEHLER:",n),process.exit(1)});export{p as alleSchluessel,x as istInt8,N as verdichte};

package/dist/src/werkzeug-nutzung.js

@@ -1,72 +1 @@
-/**
- * Welche der 122 Werkzeuge werden wirklich benutzt?
- *
- * ANLASS 19.08.2026: Die Glama-Bewertung sagt, cachly habe zu viele Werkzeuge
- * und viele liessen sich zusammenlegen. Der Einwand ist plausibel — nur konnte
- * ihm niemand mit Zahlen begegnen, weil es KEINE Messung gab. Nirgends im
- * Server wurde festgehalten, welches Werkzeug wie oft gerufen wird.
- *
- * Ohne diese Zahl ist jedes Zusammenlegen geraten. Man streicht dann das, was
- * man selbst selten benutzt — und das ist selten dasselbe wie das, was die
- * Nutzer selten benutzen.
- *
- * Diese Datei ist die Rechnung dazu, ohne Datenzugriff und ohne neues
- * Werkzeug: gezaehlt wird an der EINEN Stelle, durch die jeder Aufruf geht
- * (handleTool), und gelesen wird in `brain_metrics`, das es schon gibt. Ein
- * 123. Werkzeug, um zu messen, dass es zu viele Werkzeuge gibt, waere die
- * Pointe, die niemand will.
- */
-/** Redis-Hash je Brain: Feld = Werkzeugname, Wert = Anzahl der Aufrufe. */
-export function nutzungsSchluessel(instanceId) {
-    return `cachly:stats:tool_calls:${instanceId}`;
-}
-/**
- * Rohzaehler zu einem lesbaren Bild verdichten.
- *
- * Rein, damit sich die Verdichtung ohne Redis pruefen laesst. Ungueltige
- * Zaehler (kein Zahlwert, negativ) fallen heraus statt NaN zu erzeugen — eine
- * kaputte Zeile darf nicht die ganze Auswertung vergiften.
- */
-export function verdichte(roh, spitzeN = 15) {
-    const zeilen = [];
-    for (const [name, wert] of Object.entries(roh)) {
-        const n = typeof wert === 'number' ? wert : Number(wert);
-        if (!Number.isFinite(n) || n <= 0)
-            continue;
-        zeilen.push({ name, aufrufe: Math.floor(n) });
-    }
-    const gesamt = zeilen.reduce((s, z) => s + z.aufrufe, 0);
-    zeilen.sort((a, b) => b.aufrufe - a.aufrufe || a.name.localeCompare(b.name));
-    const spitze = zeilen.slice(0, Math.max(0, spitzeN)).map((z) => ({
-        ...z,
-        anteil: gesamt > 0 ? z.aufrufe / gesamt : 0,
-    }));
-    const summeSpitze = spitze.reduce((s, z) => s + z.aufrufe, 0);
-    return {
-        gesamt,
-        benutzte: zeilen.length,
-        spitze,
-        anteilSpitze: gesamt > 0 ? summeSpitze / gesamt : 0,
-    };
-}
-/**
- * Der Satz, der die Glama-Frage beantwortet.
- *
- * Bewusst mit der Zahl der NIE gerufenen Werkzeuge: das ist die Angabe, an der
- * sich entscheidet, ob zusammengelegt werden sollte — und sie ist unbequem
- * genug, dass niemand sie schoenreden kann.
- *
- * Ohne einen einzigen Aufruf wird NICHT behauptet, alles sei ungenutzt: eine
- * frische Instanz hat noch nichts gemessen, und "0 von 122 benutzt" waere dann
- * eine Aussage ueber die Messung, nicht ueber das Produkt.
- */
-export function nutzungInWorten(bild, werkzeugeGesamt) {
-    if (bild.gesamt === 0) {
-        return 'Noch keine Werkzeug-Aufrufe gezählt — die Messung beginnt mit dem nächsten Aufruf.';
-    }
-    const nie = Math.max(0, werkzeugeGesamt - bild.benutzte);
-    const prozent = Math.round(bild.anteilSpitze * 100);
-    return (`${bild.benutzte} von ${werkzeugeGesamt} Werkzeugen wurden hier je gerufen (${nie} nie). ` +
-        `Die ${bild.spitze.length} häufigsten tragen ${prozent} % aller ${bild.gesamt} Aufrufe.`);
-}
-//# sourceMappingURL=werkzeug-nutzung.js.map
+function i(t){return`cachly:stats:tool_calls:${t}`}function c(t,o=15){const u=[];for(const[e,n]of Object.entries(t)){const f=typeof n=="number"?n:Number(n);!Number.isFinite(f)||f<=0||u.push({name:e,aufrufe:Math.floor(f)})}const r=u.reduce((e,n)=>e+n.aufrufe,0);u.sort((e,n)=>n.aufrufe-e.aufrufe||e.name.localeCompare(n.name));const s=u.slice(0,Math.max(0,o)).map(e=>({...e,anteil:r>0?e.aufrufe/r:0})),a=s.reduce((e,n)=>e+n.aufrufe,0);return{gesamt:r,benutzte:u.length,spitze:s,anteilSpitze:r>0?a/r:0}}function m(t,o){if(t.gesamt===0)return"Noch keine Werkzeug-Aufrufe gez\xE4hlt \u2014 die Messung beginnt mit dem n\xE4chsten Aufruf.";const u=Math.max(0,o-t.benutzte),r=Math.round(t.anteilSpitze*100);return`${t.benutzte} von ${o} Werkzeugen wurden hier je gerufen (${u} nie). Die ${t.spitze.length} h\xE4ufigsten tragen ${r} % aller ${t.gesamt} Aufrufe.`}export{m as nutzungInWorten,i as nutzungsSchluessel,c as verdichte};

package/dist/src/wertbeitrag.js

@@ -1,203 +1 @@
-/**
- * Wertbeitrag — was ein einzelner Abruf zur Zeitersparnis beiträgt.
- *
- * ─── DER ANLASS ────────────────────────────────────────────────────────────
- *
- * Am 17.08.2026 zeigte das Panel eines Brains mit 475 Lektionen eine
- * Zeitersparnis von 54 Tagen und einen Gegenwert von 97.237,50 €. Nachgerechnet
- * stammte praktisch die ganze Zahl aus dem STARTER-KORPUS: `docker:layer-cache`
- * stand bei 973 Abrufen, `cache:stampede` bei 971, dahinter neun weitere
- * Starter-Lektionen mit je rund 208. Die echten, projektbezogenen Lektionen
- * standen bei zwei bis fünf.
- *
- * Der Starter-Korpus ist genau das, wofür er gedacht ist: ein Startvorrat, der
- * dafür sorgt, dass die erste Frage an ein leeres Brain nicht ins Leere geht.
- * Er ist eingekauftes Allgemeinwissen — Docker-Cache, JWT-Uhrzeitversatz,
- * N+1-Abfragen. Er ist NICHT das, was jemand über sein Projekt gelernt hat.
- *
- * Ihn in die Wertschätzung einzurechnen macht die Zahl doppelt falsch:
- *   - Sie wächst, ohne dass jemand etwas gelernt hat.
- *   - Sie wächst am schnellsten in Brains, die am wenigsten eigenes Wissen
- *     haben — dort gibt es ja nichts anderes zu treffen.
- *
- * Eine Kennzahl, die dann am besten aussieht, wenn das Produkt am wenigsten
- * leistet, ist schlimmer als gar keine.
- *
- * ─── WARUM KEINE NAMENSLISTE ───────────────────────────────────────────────
- *
- * Naheliegend wäre gewesen, die sechs auffälligen Themen hart auszuschliessen.
- * Das wäre ein Wächter, der auf den Anlass genagelt ist: Beim nächsten
- * Starter-Korpus mit anderen Namen wäre er blind. Die Starter-Lektionen tragen
- * seit ihrer Einführung `source: 'starter'` im Datensatz — genau dafür. Diese
- * Datei benutzt die Markierung, nicht die Namen.
- *
- * ─── NACHTRAG 22.08.2026: DIE MARKIERUNG GAB ES NICHT ──────────────────────
- *
- * Der Absatz darüber stand fünf Tage lang so da und war falsch. Gemessen in
- * der Gegenrede über die Zahl „Brain saved you ~1664h":
- *
- *     brain_hygiene(dry_run) → "Startvorrat entwertet (Zähler auf 0): 0"
- *     bei 543 gescannten Lektionen.
- *
- * NULL. Der Filter griff bei keiner einzigen. `docker:layer-cache` — der
- * Anlass dieser ganzen Datei — zählte weiterhin voll mit inzwischen 974
- * Abrufen.
- *
- * Der Grund: Die eingebauten Lektionen kommen über `import_public_brain`
- * herein und tragen dabei gar kein `source`-Feld. Die Markierung, auf die
- * sich der Absatz oben verlässt, wird beim Schreiben nie gesetzt.
- *
- * Das ist die eigentliche Lehre, und sie ist unbequemer als die erste: Der
- * Fix war gebaut, beschrieben und begründet — und hat nie gewirkt. Niemand
- * hat nachgemessen, ob er greift. Fünf Tage lang stand in dieser Datei ein
- * Kommentar über einen Schutz, den es nicht gab.
- *
- * Deshalb prüft `istStarterLektion` jetzt drei Dinge (Herkunft, Thema,
- * fremder Installationsweg) — und deshalb steht darunter eine Probe, die
- * nicht den Code liest, sondern eine echte Lektion durch die Funktion
- * schickt. Ein Kommentar ist kein Beweis.
- */
-import { STARTER_CORPUS } from './starter-corpus.js';
-/** fmtStunden macht aus Minuten eine lesbare Angabe ("21 h", "3 d 4 h"). */
-export function fmtStunden(minuten) {
-    const gesamt = Math.max(0, Math.round(minuten));
-    if (gesamt < 60)
-        return `${gesamt} min`;
-    const stunden = Math.floor(gesamt / 60);
-    if (stunden < 24)
-        return `${stunden} h`;
-    const tage = Math.floor(stunden / 24);
-    const rest = stunden % 24;
-    return rest > 0 ? `${tage} d ${rest} h` : `${tage} d`;
-}
-/**
- * Der ausgelieferte Startvorrat, nach Thema aufgeschlagen — ABGELEITET.
- *
- * Erster Versuch am 22.08.2026 war eine von Hand gepflegte Namensliste. Sie war
- * schon beim Schreiben falsch: sieben Themen fehlten, drei standen darin, die
- * es gar nicht gibt. Eine zweite Liste derselben Wahrheit laeuft auseinander,
- * bevor sie fertig ist.
- */
-const STARTER_NACH_THEMA = new Map(STARTER_CORPUS.map((l) => [l.topic, l.what_worked]));
-/** Die Themen des Startvorrats — fuer Aufrufer, die nur die Namen brauchen. */
-export const STARTER_THEMEN = new Set(STARTER_NACH_THEMA.keys());
-/**
- * Herkuenfte, die NICHT als eigene Lernleistung zaehlen.
- *
- * Es gibt zwei Wege, auf denen fremdes Wissen in ein Brain kommt, und sie
- * schreiben ZWEI VERSCHIEDENE Werte:
- *
- *   brain_seed_starter   (share.ts)  → source: 'starter'
- *   import_public_brain  (team.ts)   → source: 'public_brain'
- *
- * `marketplace:` und `syndicate:` sind vorgemerkt, damit der naechste
- * Einbauweg nicht wieder still durchrutscht.
- */
-const FREMDE_HERKUNFT = /^(starter|public_brain|marketplace:|syndicate:|import)/;
-/**
- * Stammt die Lektion aus fremdem Wissen statt aus eigener Arbeit?
- *
- * Solche Lektionen duerfen abgerufen werden und sind nuetzlich — sie zaehlen
- * nur nicht als etwas, das dieser Mensch oder dieses Team gelernt hat.
- *
- * ── NACHTRAG 22.08.2026: der Filter kannte nur die Haelfte ──────────────────
- *
- * Der Schutz war seit dem 17.08. gebaut, beschrieben und begruendet — und hat
- * die groesste Einzelquelle nie erwischt. Er pruefte:
- *
- *     return lesson?.source === 'starter';
- *
- * `import_public_brain` schreibt aber `source: 'public_brain'` (team.ts:1610),
- * und dahinter steht eine EIGENE eingebaute Liste von rund 40 Lektionen ueber
- * go, docker, kubernetes, react, typescript und python — darunter
- * `docker:layer-cache`, die meistabgerufene Lektion dieses Brains ueberhaupt
- * (980 Abrufe, gemessen am 22.08.2026).
- *
- * Ein Vergleich auf genau eine Zeichenkette ist blind fuer den zweiten Weg.
- * Und weil `brain_hygiene` (team.ts:1247) die Zeitersparnis aus derselben
- * Funktion NEU rechnet, machte die Luecke die Zahl nicht nur zu gross, sondern
- * beim Aufraeumen noch groesser: 1664 h → 6445 h.
- *
- * ── Warum trotzdem nicht nur ueber die Namen ────────────────────────────────
- *
- * Eine reine Namensliste wuerde eine echte Regel brechen: Wer selbst etwas
- * ueber `docker:layer-cache` lernt, hat etwas gelernt. Deshalb entscheidet
- * zuerst die Herkunft. Nur wenn gar keine dasteht — `learn_from_attempts`
- * setzt das Feld nicht — wird das Thema geprueft, und dann muss auch der TEXT
- * wortgleich der ausgelieferte sein. Ein eigener Satz zum selben Thema zaehlt.
- */
-export function istStarterLektion(lesson) {
-    if (!lesson)
-        return false;
-    if (typeof lesson.source === 'string' && lesson.source !== '') {
-        // Herkunft steht da: sie entscheidet, in beide Richtungen.
-        return FREMDE_HERKUNFT.test(lesson.source);
-    }
-    // Keine Herkunft: nur ein WORTGLEICHER Treffer aus dem Vorrat zaehlt nicht.
-    if (typeof lesson.topic !== 'string')
-        return false;
-    const ausgeliefert = STARTER_NACH_THEMA.get(lesson.topic);
-    if (ausgeliefert === undefined)
-        return false;
-    const eigener = typeof lesson.what_worked === 'string' ? lesson.what_worked : '';
-    return eigener.trim() === ausgeliefert.trim();
-}
-/**
- * Minuten, die ein Abruf dieser Lektion einspart — 0 für fremdes Wissen.
- *
- * Die Staffel (30 / 60 / 240) ist unverändert; sie stand vorher an drei
- * Stellen im Code und steht jetzt hier. `basis` erlaubt der abweichenden
- * Staffel von causal_trace (60 / 120 / 240) ihren eigenen Grundwert, ohne dass
- * die Starter-Regel ein zweites Mal geschrieben werden muss.
- */
-export function ersparteMinuten(lesson, basis = 'recall') {
-    if (!lesson || istStarterLektion(lesson))
-        return 0;
-    const sev = lesson.severity;
-    if (sev === 'critical')
-        return 240;
-    if (sev === 'major')
-        return basis === 'trace' ? 120 : 60;
-    return basis === 'trace' ? 60 : 30;
-}
-/**
- * Zaehlt dieser Abruf ueberhaupt Zeit — oder ist es ein Wiedersehen?
- *
- * ── DER ZWEITE BEFUND VOM 22.08.2026 ────────────────────────────────────────
- *
- * Der Startvorrat-Filter war nur die halbe Ursache. Die andere Haelfte:
- * Zeitersparnis wurde bei JEDEM Abruf erneut gutgeschrieben.
- *
- * `smart_recall` schreibt bis zu FUENF Lektionen pro Aufruf die volle
- * Recherchezeit gut (brain.ts:1725 ff.). Die Anleitung des Servers verlangt
- * einen Aufruf "BEFORE every task", und eingeblendete Lektionen kommen
- * zusaetzlich bei jedem Prompt. Zehn Aufgaben in einer Sitzung konnten so
- * rechnerisch zweihundert Stunden erzeugen.
- *
- * Gemessen: Dieses Brain ist am 01.06.2026 entstanden, 82 Tage alt, und meldete
- * 1664,5 Stunden. Eine Person haette in 82 Tagen zu acht Stunden 656 Stunden
- * gehabt. Die Zahl war nicht zu hoch — sie war unmoeglich.
- *
- * ── Die Regel, die haelt ────────────────────────────────────────────────────
- *
- * Die Zusage lautet "time not re-researching known fixes". Recherchiert wird
- * EINMAL. Wer dieselbe Lektion zum neunhundertsten Mal sieht, spart nicht zum
- * neunhundertsten Mal eine Recherche — er spart ein Nachschlagen.
- *
- * Also: jede Lektion zaehlt genau EINMAL, beim ersten Abruf. Damit ist die
- * Zahl nach oben durch den Wissensstand begrenzt statt durch die Nutzung, sie
- * kann nicht mehr schneller wachsen als gelernt wird — und das Einblenden
- * treibt sie gar nicht mehr.
- *
- * Das ist dieselbe Fehlerklasse wie `cachly:metric-inflation-fixed` (PR #158,
- * stuendliche Heartbeat-Pings blaehten die ROI-Zahlen auf). Damals wurde die
- * eine Quelle abgestellt; die Bauart, die aus Wiederholung Wert macht, blieb.
- */
-export function zaehltAlsErsparnis(lesson) {
-    if (!lesson || istStarterLektion(lesson))
-        return false;
-    // recall_count ist der Stand VOR diesem Abruf. 0 heisst: das erste Mal.
-    const bisher = typeof lesson.recall_count === 'number' ? lesson.recall_count : 0;
-    return bisher <= 0;
-}
-//# sourceMappingURL=wertbeitrag.js.map
+import{STARTER_CORPUS as a}from"./starter-corpus.js";function p(t){const r=Math.max(0,Math.round(t));if(r<60)return`${r} min`;const e=Math.floor(r/60);if(e<24)return`${e} h`;const n=Math.floor(e/24),i=e%24;return i>0?`${n} d ${i} h`:`${n} d`}const c=new Map(a.map(t=>[t.topic,t.what_worked])),m=new Set(c.keys()),u=/^(starter|public_brain|marketplace:|syndicate:|import)/;function o(t){if(!t)return!1;if(typeof t.source=="string"&&t.source!=="")return u.test(t.source);if(typeof t.topic!="string")return!1;const r=c.get(t.topic);return r===void 0?!1:(typeof t.what_worked=="string"?t.what_worked:"").trim()===r.trim()}function h(t,r="recall"){if(!t||o(t))return 0;const e=t.severity;return e==="critical"?240:e==="major"?r==="trace"?120:60:r==="trace"?60:30}function s(t){return!t||o(t)?!1:(typeof t.recall_count=="number"?t.recall_count:0)<=0}export{m as STARTER_THEMEN,h as ersparteMinuten,p as fmtStunden,o as istStarterLektion,s as zaehltAlsErsparnis};

package/dist/src/wirkungsspur.js

@@ -0,0 +1 @@
+const d=500,m=500;function o(e,t){return typeof e=="string"?e.trim().slice(0,t):""}function p(e,t){const r=o(e.frage,500);if(!r)return{ok:!1,grund:"frage fehlt \u2014 ohne die Frage ist der Eintrag wertlos"};const n=o(e.thema,200);return n?typeof e.geholfen!="boolean"?{ok:!1,grund:'geholfen muss true oder false sein \u2014 "weiss nicht" ist keine Rueckmeldung'}:typeof e.platz!="number"||!Number.isInteger(e.platz)||e.platz<0?{ok:!1,grund:"platz muss eine ganze Zahl ab 0 sein (0 = die Lektion stand gar nicht in der Antwort)"}:{ok:!0,eintrag:{ts:t,quelle:"gemeldet",frage:r,thema:n,geholfen:e.geholfen,platz:e.platz,notiz:o(e.notiz,500),autor:o(e.autor,80)}}:{ok:!1,grund:"thema fehlt \u2014 welche Lektion ist gemeint?"}}function A(e,t,r){if(!e)return null;const n=o(e.frage,500),f=o(t,200);if(!n||!f||!Array.isArray(e.themen))return null;const l=e.themen.indexOf(f);return{ts:r,quelle:"abgeleitet",frage:n,thema:f,geholfen:!0,platz:l===-1?0:l+1,notiz:l===-1?"automatisch: geoeffnet, obwohl nicht in der Antwort":"automatisch: aus der Antwort geoeffnet",autor:""}}const a=3;function c(e){return e.geholfen&&e.platz===0?"fehlender-treffer":e.geholfen&&e.platz>a?"zu-weit-hinten":!e.geholfen&&e.platz>0&&e.platz<=a?"falsch-und-sicher":e.geholfen?"bestaetigung":"unauffaellig"}function z(e){const t={"fehlender-treffer":0,"zu-weit-hinten":0,"falsch-und-sicher":0,bestaetigung:0,unauffaellig:0};let r=0,n=0,f=0,l=0,s=0,u=0,h=0;for(const i of e){t[c(i)]++;const g=i.platz>0&&i.platz<=a;if(i.quelle==="abgeleitet"){n++,u++,g&&h++;continue}r++,i.geholfen&&(f++,l++,g&&s++)}return{gesamt:e.length,gemeldet:r,abgeleitet:n,geholfen:f,trefferquote:l===0?null:s/l,auswahlquote:u===0?null:h/u,nachLehrwert:t}}export{a as SICHTBARE_PLAETZE,c as lehrwert,A as leiteAb,p as pruefeWirkung,z as werteAus};

package/glama.json

@@ -1,6 +1,6 @@
 {
   "$schema": "https://glama.ai/mcp/schemas/server.json",
-  "version": "0.10.129",
+  "version": "0.10.130",
   "maintainers": [
     "HeinrichNebula"
   ],

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@cachly-dev/mcp-server",
-  "version": "0.10.129",
+  "version": "0.10.130",
   "mcpName": "io.github.cachly-dev/mcp-server",
-  "description": "Your AI forgets everything between sessions. cachly fixes that permanently: 122 MCP tools for Claude Code, Cursor, Copilot & Windsurf. Learns from every bug fix, commit and CI run. Arrives pre-briefed. Free tier forever, EU servers, GDPR.",
+  "description": "Your AI forgets everything between sessions. cachly fixes that permanently: 123 MCP tools for Claude Code, Cursor, Copilot & Windsurf. Learns from every bug fix, commit and CI run. Arrives pre-briefed. Free tier forever, EU servers, GDPR.",
   "type": "module",
   "files": [
-    "dist/index.*",
-    "dist/src/**/*",
-    "dist/packages/**/*",
+    "dist/index.js",
+    "dist/src/**/*.js",
+    "dist/packages/**/*.js",
     "scripts/postinstall.js",
     "server.json",
     "glama.json"
@@ -32,7 +32,7 @@
     "verify-tool-spec-snapshots": "node scripts/tool-spec-snapshots.mjs check",
     "verify-tool-counts": "node scripts/verify-tool-counts.mjs",
     "verify-capabilities": "node scripts/verify-capabilities.mjs",
-    "build": "tsc && node scripts/bauabdruck.mjs",
+    "build": "tsc && node scripts/paket-schliessen.mjs && node scripts/bauabdruck.mjs",
     "postinstall": "node scripts/postinstall.js",
     "dev": "tsx src/index.ts",
     "start": "node dist/src/index.js",
@@ -60,6 +60,7 @@
   "devDependencies": {
     "@eslint/js": "^9.39.4",
     "@types/node": "^22",
+    "esbuild": "^0.28.2",
     "eslint": "^9",
     "gpt-tokenizer": "^3.4.0",
     "tsx": "^4.23.12",
@@ -68,7 +69,7 @@
     "vitest": "^3.2.4"
   },
   "overrides": {
-    "esbuild": "^0.28.2"
+    "esbuild": "$esbuild"
   },
   "engines": {
     "node": ">=20"

package/server.json

@@ -1,18 +1,18 @@
 {
   "$schema": "https://static.modelcontextprotocol.io/schemas/2025-12-11/server.schema.json",
   "name": "io.github.cachly-dev/mcp-server",
-  "description": "Persistent memory + causal root-cause analysis for AI coding agents. 122 MCP tools. EU, GDPR.",
+  "description": "Persistent memory + causal root-cause analysis for AI coding agents. 123 MCP tools. EU, GDPR.",
   "repository": {
     "url": "https://github.com/cachly-dev/cachly-mcp",
     "source": "github"
   },
-  "version": "0.10.129",
+  "version": "0.10.130",
   "packages": [
     {
       "registryType": "npm",
       "name": "@cachly-dev/mcp-server",
       "identifier": "@cachly-dev/mcp-server",
-      "version": "0.10.129",
+      "version": "0.10.130",
       "transport": {
         "type": "stdio"
       }

package/dist/index.d.ts

@@ -1 +0,0 @@
-import './src/index.js';

package/dist/index.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../index.ts"],"names":[],"mappings":"AAAA,4EAA4E;AAC5E,+EAA+E;AAC/E,+EAA+E;AAC/E,4EAA4E;AAC5E,wCAAwC;AACxC,OAAO,gBAAgB,CAAC"}

package/dist/packages/telegram-notify/client.d.ts

@@ -1,19 +0,0 @@
-/**
- * telegram-notify — shared Telegram notification client.
- *
- * Used by cachly-mcp (TypeScript) and TCO backend (Python via client.py).
- * Single source of truth for: emoji map, message format, env var convention.
- *
- * Interface: notify(app, event, payload)
- *
- * Env vars:
- *   TELEGRAM_BOT_TOKEN          — bot token from @BotFather
- *   {APP_UPPER}_TELEGRAM_CHAT_ID — app-specific channel (e.g. CACHLY_TELEGRAM_CHAT_ID)
- *   TELEGRAM_CHAT_ID             — fallback for all apps
- *
- * No-op when unconfigured. Never throws.
- *
- * Note: emoji map is kept in sync with emojis.json (Python reads the JSON file at runtime).
- */
-export declare function formatMessage(app: string, event: string, payload: Record<string, unknown>): string;
-export declare function notify(app: string, event: string, payload?: Record<string, unknown>): Promise<void>;

package/dist/packages/telegram-notify/client.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"client.js","sourceRoot":"","sources":["../../../packages/telegram-notify/client.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;GAgBG;AAKH,MAAM,KAAK,GAA2B;IACpC,SAAS,EAAW,IAAI;IACxB,UAAU,EAAU,IAAI;IACxB,SAAS,EAAW,GAAG;IACvB,UAAU,EAAU,IAAI;IACxB,OAAO,EAAa,IAAI;IACxB,SAAS,EAAW,IAAI;IACxB,OAAO,EAAa,IAAI;IACxB,eAAe,EAAK,IAAI;IACxB,UAAU,EAAU,IAAI;IACxB,UAAU,EAAU,IAAI;IACxB,SAAS,EAAW,IAAI;IACxB,YAAY,EAAQ,KAAK;IACzB,YAAY,EAAQ,KAAK;IACzB,KAAK,EAAe,IAAI;IACxB,cAAc,EAAM,IAAI;IACxB,eAAe,EAAK,IAAI;IACxB,QAAQ,EAAY,IAAI;IACxB,UAAU,EAAU,IAAI;IACxB,WAAW,EAAS,IAAI;IACxB,OAAO,EAAa,IAAI;CACzB,CAAC;AAEF,SAAS,QAAQ;IACf,OAAO,OAAO,CAAC,GAAG,CAAC,kBAAkB,IAAI,EAAE,CAAC;AAC9C,CAAC;AAED,SAAS,SAAS,CAAC,GAAW;IAC5B,MAAM,GAAG,GAAG,GAAG,GAAG,CAAC,WAAW,EAAE,mBAAmB,CAAC;IACpD,OAAO,OAAO,CAAC,GAAG,CAAC,GAAG,CAAC,IAAI,OAAO,CAAC,GAAG,CAAC,gBAAgB,IAAI,EAAE,CAAC;AAChE,CAAC;AAED,MAAM,UAAU,aAAa,CAC3B,GAAW,EACX,KAAa,EACb,OAAgC;IAEhC,MAAM,IAAI,GAAG,KAAK,CAAC,KAAK,CAAC,IAAI,KAAK,CAAC,SAAS,CAAC,CAAC;IAC9C,MAAM,KAAK,GAAG,CAAC,GAAG,IAAI,KAAK,GAAG,CAAC,WAAW,EAAE,SAAS,KAAK,IAAI,CAAC,CAAC;IAChE,KAAK,MAAM,CAAC,CAAC,EAAE,CAAC,CAAC,IAAI,MAAM,CAAC,OAAO,CAAC,OAAO,CAAC,EAAE,CAAC;QAC7C,IAAI,CAAC,KAAK,IAAI,IAAI,CAAC,KAAK,SAAS,IAAI,CAAC,KAAK,EAAE,EAAE,CAAC;YAC9C,KAAK,CAAC,IAAI,CAAC,KAAK,CAAC,OAAO,MAAM,CAAC,CAAC,CAAC,IAAI,CAAC,CAAC;QACzC,CAAC;IACH,CAAC;IACD,OAAO,KAAK,CAAC,IAAI,CAAC,IAAI,CAAC,CAAC;AAC1B,CAAC;AAED,MAAM,CAAC,KAAK,UAAU,MAAM,CAC1B,GAAW,EACX,KAAa,EACb,UAAmC,EAAE;IAErC,MAAM,KAAK,GAAG,QAAQ,EAAE,CAAC;IACzB,MAAM,MAAM,GAAG,SAAS,CAAC,GAAG,CAAC,CAAC;IAC9B,IAAI,CAAC,KAAK,IAAI,CAAC,MAAM;QAAE,OAAO;IAC9B,IAAI,CAAC;QACH,MAAM,IAAI,GAAG,aAAa,CAAC,GAAG,EAAE,KAAK,EAAE,OAAO,CAAC,CAAC;QAChD,MAAM,KAAK,CAAC,+BAA+B,KAAK,cAAc,EAAE;YAC9D,MAAM,EAAE,MAAM;YACd,OAAO,EAAE,EAAE,cAAc,EAAE,kBAAkB,EAAE;YAC/C,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,UAAU,EAAE,UAAU,EAAE,CAAC;YACvE,MAAM,EAAE,WAAW,CAAC,OAAO,CAAC,IAAI,CAAC;SAClC,CAAC,CAAC;IACL,CAAC;IAAC,MAAM,CAAC;QACP,eAAe;IACjB,CAAC;AACH,CAAC"}