@futdevpro/nts-dynamo 1.15.64 → 1.15.68

package/build/_modules/local-vector-search/_services/lvs-bm25.util.d.ts

@@ -1,89 +1,89 @@
-/**
- * BM25 text-search ranking util a LVS hybrid search-hez (FR-004).
- *
- * Pure TypeScript, dependency-free. In-memory corpus alapjan szamol score-okat,
- * NEM perzisztal indexet (a hybrid hivasonkent ujraepiti a corpus-t a candidate
- * dokumentumokon — kis (~100..10000 dokumentum) LVS-corpus eseten ez gyors es
- * egyszeru).
- *
- * Canonical params: k1=1.2, b=0.75 (industry standard a "lucene-szeru"
- * implementaciokban). NEM expose-oltak — ha kell, FR-002 kovetkezo iteracioban
- * tehetjuk parameterizalhatova.
- *
- * Tokenizer: `text.toLowerCase().match(/\w+/g) || []`. Case-insensitive,
- * alphanumeric+underscore boundary-k. `UserController` egy token marad (jo az
- * identifier match-re), `auth-flow` ket tokenre esik (auth + flow).
- *
- * IDF formula (BM25+): `log((N - df + 0.5) / (df + 0.5) + 1)`. A +1 a logon
- * belul garantalja, hogy a kozos szavak is pozitiv (kicsi) IDF-et kapjanak,
- * NEM negativ-t — fontos a hybrid score-merge-nel hogy ne huzzon le dokumentumot
- * ahol kozos szo szerepel.
- */
-/**
- * Egy dokumentum BM25-score-ja egy query ellen, egy elore-felepitett corpus
- * konteztusaban.
- */
-export interface DyNTS_LVS_BM25_DocScore {
-    /** Dokumentum azonosito (mint az LVS_SearchResult `id`-jaben). */
-    id: string;
-    /** Nyers BM25 score (0..∞). NEM normalizalt. */
-    score: number;
-}
-/**
- * Felepitett BM25 corpus — egy adott dokumentumhalmaz indexe. A `score()` az
- * indexen kerdez le egy query-t es minden dokumentumra ad egy score-t.
- *
- * Egy corpus egyszer-hasznalatos a hybrid search hivasban — NEM kell cache-elni,
- * a felepites O(N * |doc|) ami pici N-re elhanyagolhato.
- */
-export declare class DyNTS_LVS_BM25_Corpus {
-    /** Tokenizalt dokumentumok: id -> tokens. */
-    private readonly docTokens;
-    /** Doc-length: id -> token count. */
-    private readonly docLengths;
-    /** Term -> doc-frequency (hany docban szerepel az adott term, legalabb 1x). */
-    private readonly termDocFreq;
-    /** Term -> id -> term-frequency a docban. */
-    private readonly termFreqByDoc;
-    /** Atlagos dokumentum-hossz (token count). */
-    private avgDocLength;
-    /** Total doc count. */
-    private docCount;
-    /**
-     * Letrehoz egy uj corpus-t a megadott id->text parok-bol.
-     * NEM dob hibat ures input-ra — ures corpus ervenyes (minden score = 0).
-     */
-    constructor(docs: {
-        id: string;
-        text: string;
-    }[]);
-    /**
-     * Public tokenizer — exportalt, hogy spec-ek + hivok ugyanazt a normalizalast
-     * tudjak hasznalni mint a corpus.
-     */
-    static tokenize(text: string): string[];
-    /**
-     * Visszaadja a corpus dokumentum-szamat (NEM-ures docok).
-     */
-    size(): number;
-    /**
-     * BM25 score minden dokumentumra a query-re.
-     *
-     * Ures query → minden score 0 (degenerate case; a hivo kezelje ha kell).
-     * Ures corpus → ures array.
-     */
-    score(query: string): DyNTS_LVS_BM25_DocScore[];
-}
-/**
- * Min-max normalizalas [0,1] tartomanyra. A hybrid score-merge-hez kell a BM25
- * score-okat a candidate-szetten 0..1 sav-ba hozni (a cosine mar 0..1).
- *
- * Edge case-ek:
- *  - Ures array → [].
- *  - Minden score azonos (max-min === 0) → minden 0.0 (NEM 0.5 vagy 1.0; ha
- *    nincs diszkriminacio, ne tegyunk hozza signal-t).
- *  - Negativ score-ok (BM25+IDF garantal pozitivat, de defensive): a min-max
- *    ugyanugy mukodik.
- */
-export declare function dyNTS_LVS_BM25_minMaxNormalize(scores: DyNTS_LVS_BM25_DocScore[]): DyNTS_LVS_BM25_DocScore[];
+/**
+ * BM25 text-search ranking util a LVS hybrid search-hez (FR-004).
+ *
+ * Pure TypeScript, dependency-free. In-memory corpus alapjan szamol score-okat,
+ * NEM perzisztal indexet (a hybrid hivasonkent ujraepiti a corpus-t a candidate
+ * dokumentumokon — kis (~100..10000 dokumentum) LVS-corpus eseten ez gyors es
+ * egyszeru).
+ *
+ * Canonical params: k1=1.2, b=0.75 (industry standard a "lucene-szeru"
+ * implementaciokban). NEM expose-oltak — ha kell, FR-002 kovetkezo iteracioban
+ * tehetjuk parameterizalhatova.
+ *
+ * Tokenizer: `text.toLowerCase().match(/\w+/g) || []`. Case-insensitive,
+ * alphanumeric+underscore boundary-k. `UserController` egy token marad (jo az
+ * identifier match-re), `auth-flow` ket tokenre esik (auth + flow).
+ *
+ * IDF formula (BM25+): `log((N - df + 0.5) / (df + 0.5) + 1)`. A +1 a logon
+ * belul garantalja, hogy a kozos szavak is pozitiv (kicsi) IDF-et kapjanak,
+ * NEM negativ-t — fontos a hybrid score-merge-nel hogy ne huzzon le dokumentumot
+ * ahol kozos szo szerepel.
+ */
+/**
+ * Egy dokumentum BM25-score-ja egy query ellen, egy elore-felepitett corpus
+ * konteztusaban.
+ */
+export interface DyNTS_LVS_BM25_DocScore {
+    /** Dokumentum azonosito (mint az LVS_SearchResult `id`-jaben). */
+    id: string;
+    /** Nyers BM25 score (0..∞). NEM normalizalt. */
+    score: number;
+}
+/**
+ * Felepitett BM25 corpus — egy adott dokumentumhalmaz indexe. A `score()` az
+ * indexen kerdez le egy query-t es minden dokumentumra ad egy score-t.
+ *
+ * Egy corpus egyszer-hasznalatos a hybrid search hivasban — NEM kell cache-elni,
+ * a felepites O(N * |doc|) ami pici N-re elhanyagolhato.
+ */
+export declare class DyNTS_LVS_BM25_Corpus {
+    /** Tokenizalt dokumentumok: id -> tokens. */
+    private readonly docTokens;
+    /** Doc-length: id -> token count. */
+    private readonly docLengths;
+    /** Term -> doc-frequency (hany docban szerepel az adott term, legalabb 1x). */
+    private readonly termDocFreq;
+    /** Term -> id -> term-frequency a docban. */
+    private readonly termFreqByDoc;
+    /** Atlagos dokumentum-hossz (token count). */
+    private avgDocLength;
+    /** Total doc count. */
+    private docCount;
+    /**
+     * Letrehoz egy uj corpus-t a megadott id->text parok-bol.
+     * NEM dob hibat ures input-ra — ures corpus ervenyes (minden score = 0).
+     */
+    constructor(docs: {
+        id: string;
+        text: string;
+    }[]);
+    /**
+     * Public tokenizer — exportalt, hogy spec-ek + hivok ugyanazt a normalizalast
+     * tudjak hasznalni mint a corpus.
+     */
+    static tokenize(text: string): string[];
+    /**
+     * Visszaadja a corpus dokumentum-szamat (NEM-ures docok).
+     */
+    size(): number;
+    /**
+     * BM25 score minden dokumentumra a query-re.
+     *
+     * Ures query → minden score 0 (degenerate case; a hivo kezelje ha kell).
+     * Ures corpus → ures array.
+     */
+    score(query: string): DyNTS_LVS_BM25_DocScore[];
+}
+/**
+ * Min-max normalizalas [0,1] tartomanyra. A hybrid score-merge-hez kell a BM25
+ * score-okat a candidate-szetten 0..1 sav-ba hozni (a cosine mar 0..1).
+ *
+ * Edge case-ek:
+ *  - Ures array → [].
+ *  - Minden score azonos (max-min === 0) → minden 0.0 (NEM 0.5 vagy 1.0; ha
+ *    nincs diszkriminacio, ne tegyunk hozza signal-t).
+ *  - Negativ score-ok (BM25+IDF garantal pozitivat, de defensive): a min-max
+ *    ugyanugy mukodik.
+ */
+export declare function dyNTS_LVS_BM25_minMaxNormalize(scores: DyNTS_LVS_BM25_DocScore[]): DyNTS_LVS_BM25_DocScore[];
 //# sourceMappingURL=lvs-bm25.util.d.ts.map

package/build/_modules/local-vector-search/_services/lvs-bm25.util.js

@@ -1,190 +1,190 @@
-"use strict";
-/**
- * BM25 text-search ranking util a LVS hybrid search-hez (FR-004).
- *
- * Pure TypeScript, dependency-free. In-memory corpus alapjan szamol score-okat,
- * NEM perzisztal indexet (a hybrid hivasonkent ujraepiti a corpus-t a candidate
- * dokumentumokon — kis (~100..10000 dokumentum) LVS-corpus eseten ez gyors es
- * egyszeru).
- *
- * Canonical params: k1=1.2, b=0.75 (industry standard a "lucene-szeru"
- * implementaciokban). NEM expose-oltak — ha kell, FR-002 kovetkezo iteracioban
- * tehetjuk parameterizalhatova.
- *
- * Tokenizer: `text.toLowerCase().match(/\w+/g) || []`. Case-insensitive,
- * alphanumeric+underscore boundary-k. `UserController` egy token marad (jo az
- * identifier match-re), `auth-flow` ket tokenre esik (auth + flow).
- *
- * IDF formula (BM25+): `log((N - df + 0.5) / (df + 0.5) + 1)`. A +1 a logon
- * belul garantalja, hogy a kozos szavak is pozitiv (kicsi) IDF-et kapjanak,
- * NEM negativ-t — fontos a hybrid score-merge-nel hogy ne huzzon le dokumentumot
- * ahol kozos szo szerepel.
- */
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.DyNTS_LVS_BM25_Corpus = void 0;
-exports.dyNTS_LVS_BM25_minMaxNormalize = dyNTS_LVS_BM25_minMaxNormalize;
-/** BM25 k1 parameter (term saturation control). Canonical default. */
-const BM25_K1 = 1.2;
-/** BM25 b parameter (length normalization weight, 0=off, 1=full). Canonical default. */
-const BM25_B = 0.75;
-/** Token regex — alphanumeric + underscore. */
-const TOKEN_REGEX = /\w+/g;
-/**
- * Felepitett BM25 corpus — egy adott dokumentumhalmaz indexe. A `score()` az
- * indexen kerdez le egy query-t es minden dokumentumra ad egy score-t.
- *
- * Egy corpus egyszer-hasznalatos a hybrid search hivasban — NEM kell cache-elni,
- * a felepites O(N * |doc|) ami pici N-re elhanyagolhato.
- */
-class DyNTS_LVS_BM25_Corpus {
-    /** Tokenizalt dokumentumok: id -> tokens. */
-    docTokens = new Map();
-    /** Doc-length: id -> token count. */
-    docLengths = new Map();
-    /** Term -> doc-frequency (hany docban szerepel az adott term, legalabb 1x). */
-    termDocFreq = new Map();
-    /** Term -> id -> term-frequency a docban. */
-    termFreqByDoc = new Map();
-    /** Atlagos dokumentum-hossz (token count). */
-    avgDocLength = 0;
-    /** Total doc count. */
-    docCount = 0;
-    /**
-     * Letrehoz egy uj corpus-t a megadott id->text parok-bol.
-     * NEM dob hibat ures input-ra — ures corpus ervenyes (minden score = 0).
-     */
-    constructor(docs) {
-        if (!Array.isArray(docs) || docs.length === 0) {
-            return;
-        }
-        let totalLength = 0;
-        for (const doc of docs) {
-            if (!doc || typeof doc.id !== 'string' || typeof doc.text !== 'string') {
-                continue;
-            }
-            const tokens = DyNTS_LVS_BM25_Corpus.tokenize(doc.text);
-            this.docTokens.set(doc.id, tokens);
-            this.docLengths.set(doc.id, tokens.length);
-            totalLength += tokens.length;
-            // Term-frequency a docban
-            const localTf = new Map();
-            for (const tok of tokens) {
-                localTf.set(tok, (localTf.get(tok) ?? 0) + 1);
-            }
-            for (const [term, tf] of localTf) {
-                // Doc-frequency: +1 per term, per doc
-                this.termDocFreq.set(term, (this.termDocFreq.get(term) ?? 0) + 1);
-                // Term-freq-by-doc reverse index
-                let perDoc = this.termFreqByDoc.get(term);
-                if (!perDoc) {
-                    perDoc = new Map();
-                    this.termFreqByDoc.set(term, perDoc);
-                }
-                perDoc.set(doc.id, tf);
-            }
-        }
-        this.docCount = this.docTokens.size;
-        this.avgDocLength = this.docCount > 0 ? totalLength / this.docCount : 0;
-    }
-    /**
-     * Public tokenizer — exportalt, hogy spec-ek + hivok ugyanazt a normalizalast
-     * tudjak hasznalni mint a corpus.
-     */
-    static tokenize(text) {
-        if (typeof text !== 'string' || text.length === 0) {
-            return [];
-        }
-        return text.toLowerCase().match(TOKEN_REGEX) ?? [];
-    }
-    /**
-     * Visszaadja a corpus dokumentum-szamat (NEM-ures docok).
-     */
-    size() {
-        return this.docCount;
-    }
-    /**
-     * BM25 score minden dokumentumra a query-re.
-     *
-     * Ures query → minden score 0 (degenerate case; a hivo kezelje ha kell).
-     * Ures corpus → ures array.
-     */
-    score(query) {
-        if (this.docCount === 0) {
-            return [];
-        }
-        const queryTokens = DyNTS_LVS_BM25_Corpus.tokenize(query);
-        if (queryTokens.length === 0) {
-            // Minden doc 0 score-t kap
-            const results = [];
-            for (const id of this.docTokens.keys()) {
-                results.push({ id: id, score: 0 });
-            }
-            return results;
-        }
-        // Egyedi query-termek halmaza (ismetlodes nem ad nagyobb IDF-et)
-        const uniqueTerms = Array.from(new Set(queryTokens));
-        // Pre-compute IDF a query-termekre
-        const idfMap = new Map();
-        for (const term of uniqueTerms) {
-            const df = this.termDocFreq.get(term) ?? 0;
-            // BM25+ IDF: log((N - df + 0.5) / (df + 0.5) + 1)
-            const idf = Math.log((this.docCount - df + 0.5) / (df + 0.5) + 1);
-            idfMap.set(term, idf);
-        }
-        // Per-doc BM25 score
-        const results = [];
-        for (const [docId, docLen] of this.docLengths) {
-            let score = 0;
-            for (const term of uniqueTerms) {
-                const tf = this.termFreqByDoc.get(term)?.get(docId) ?? 0;
-                if (tf === 0) {
-                    continue;
-                }
-                const idf = idfMap.get(term) ?? 0;
-                const norm = 1 - BM25_B + BM25_B * (docLen / (this.avgDocLength || 1));
-                score += idf * (tf * (BM25_K1 + 1)) / (tf + BM25_K1 * norm);
-            }
-            results.push({ id: docId, score: score });
-        }
-        return results;
-    }
-}
-exports.DyNTS_LVS_BM25_Corpus = DyNTS_LVS_BM25_Corpus;
-/**
- * Min-max normalizalas [0,1] tartomanyra. A hybrid score-merge-hez kell a BM25
- * score-okat a candidate-szetten 0..1 sav-ba hozni (a cosine mar 0..1).
- *
- * Edge case-ek:
- *  - Ures array → [].
- *  - Minden score azonos (max-min === 0) → minden 0.0 (NEM 0.5 vagy 1.0; ha
- *    nincs diszkriminacio, ne tegyunk hozza signal-t).
- *  - Negativ score-ok (BM25+IDF garantal pozitivat, de defensive): a min-max
- *    ugyanugy mukodik.
- */
-function dyNTS_LVS_BM25_minMaxNormalize(scores) {
-    if (!Array.isArray(scores) || scores.length === 0) {
-        return [];
-    }
-    let min = Infinity;
-    let max = -Infinity;
-    for (const s of scores) {
-        if (s.score < min) {
-            min = s.score;
-        }
-        if (s.score > max) {
-            max = s.score;
-        }
-    }
-    const range = max - min;
-    if (range === 0) {
-        // Nincs diszkriminacio — minden 0.0 (NEM huzzon le, NEM huzzon fel)
-        return scores.map((s) => ({
-            id: s.id, score: 0,
-        }));
-    }
-    return scores.map((s) => ({
-        id: s.id,
-        score: (s.score - min) / range,
-    }));
-}
+"use strict";
+/**
+ * BM25 text-search ranking util a LVS hybrid search-hez (FR-004).
+ *
+ * Pure TypeScript, dependency-free. In-memory corpus alapjan szamol score-okat,
+ * NEM perzisztal indexet (a hybrid hivasonkent ujraepiti a corpus-t a candidate
+ * dokumentumokon — kis (~100..10000 dokumentum) LVS-corpus eseten ez gyors es
+ * egyszeru).
+ *
+ * Canonical params: k1=1.2, b=0.75 (industry standard a "lucene-szeru"
+ * implementaciokban). NEM expose-oltak — ha kell, FR-002 kovetkezo iteracioban
+ * tehetjuk parameterizalhatova.
+ *
+ * Tokenizer: `text.toLowerCase().match(/\w+/g) || []`. Case-insensitive,
+ * alphanumeric+underscore boundary-k. `UserController` egy token marad (jo az
+ * identifier match-re), `auth-flow` ket tokenre esik (auth + flow).
+ *
+ * IDF formula (BM25+): `log((N - df + 0.5) / (df + 0.5) + 1)`. A +1 a logon
+ * belul garantalja, hogy a kozos szavak is pozitiv (kicsi) IDF-et kapjanak,
+ * NEM negativ-t — fontos a hybrid score-merge-nel hogy ne huzzon le dokumentumot
+ * ahol kozos szo szerepel.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DyNTS_LVS_BM25_Corpus = void 0;
+exports.dyNTS_LVS_BM25_minMaxNormalize = dyNTS_LVS_BM25_minMaxNormalize;
+/** BM25 k1 parameter (term saturation control). Canonical default. */
+const BM25_K1 = 1.2;
+/** BM25 b parameter (length normalization weight, 0=off, 1=full). Canonical default. */
+const BM25_B = 0.75;
+/** Token regex — alphanumeric + underscore. */
+const TOKEN_REGEX = /\w+/g;
+/**
+ * Felepitett BM25 corpus — egy adott dokumentumhalmaz indexe. A `score()` az
+ * indexen kerdez le egy query-t es minden dokumentumra ad egy score-t.
+ *
+ * Egy corpus egyszer-hasznalatos a hybrid search hivasban — NEM kell cache-elni,
+ * a felepites O(N * |doc|) ami pici N-re elhanyagolhato.
+ */
+class DyNTS_LVS_BM25_Corpus {
+    /** Tokenizalt dokumentumok: id -> tokens. */
+    docTokens = new Map();
+    /** Doc-length: id -> token count. */
+    docLengths = new Map();
+    /** Term -> doc-frequency (hany docban szerepel az adott term, legalabb 1x). */
+    termDocFreq = new Map();
+    /** Term -> id -> term-frequency a docban. */
+    termFreqByDoc = new Map();
+    /** Atlagos dokumentum-hossz (token count). */
+    avgDocLength = 0;
+    /** Total doc count. */
+    docCount = 0;
+    /**
+     * Letrehoz egy uj corpus-t a megadott id->text parok-bol.
+     * NEM dob hibat ures input-ra — ures corpus ervenyes (minden score = 0).
+     */
+    constructor(docs) {
+        if (!Array.isArray(docs) || docs.length === 0) {
+            return;
+        }
+        let totalLength = 0;
+        for (const doc of docs) {
+            if (!doc || typeof doc.id !== 'string' || typeof doc.text !== 'string') {
+                continue;
+            }
+            const tokens = DyNTS_LVS_BM25_Corpus.tokenize(doc.text);
+            this.docTokens.set(doc.id, tokens);
+            this.docLengths.set(doc.id, tokens.length);
+            totalLength += tokens.length;
+            // Term-frequency a docban
+            const localTf = new Map();
+            for (const tok of tokens) {
+                localTf.set(tok, (localTf.get(tok) ?? 0) + 1);
+            }
+            for (const [term, tf] of localTf) {
+                // Doc-frequency: +1 per term, per doc
+                this.termDocFreq.set(term, (this.termDocFreq.get(term) ?? 0) + 1);
+                // Term-freq-by-doc reverse index
+                let perDoc = this.termFreqByDoc.get(term);
+                if (!perDoc) {
+                    perDoc = new Map();
+                    this.termFreqByDoc.set(term, perDoc);
+                }
+                perDoc.set(doc.id, tf);
+            }
+        }
+        this.docCount = this.docTokens.size;
+        this.avgDocLength = this.docCount > 0 ? totalLength / this.docCount : 0;
+    }
+    /**
+     * Public tokenizer — exportalt, hogy spec-ek + hivok ugyanazt a normalizalast
+     * tudjak hasznalni mint a corpus.
+     */
+    static tokenize(text) {
+        if (typeof text !== 'string' || text.length === 0) {
+            return [];
+        }
+        return text.toLowerCase().match(TOKEN_REGEX) ?? [];
+    }
+    /**
+     * Visszaadja a corpus dokumentum-szamat (NEM-ures docok).
+     */
+    size() {
+        return this.docCount;
+    }
+    /**
+     * BM25 score minden dokumentumra a query-re.
+     *
+     * Ures query → minden score 0 (degenerate case; a hivo kezelje ha kell).
+     * Ures corpus → ures array.
+     */
+    score(query) {
+        if (this.docCount === 0) {
+            return [];
+        }
+        const queryTokens = DyNTS_LVS_BM25_Corpus.tokenize(query);
+        if (queryTokens.length === 0) {
+            // Minden doc 0 score-t kap
+            const results = [];
+            for (const id of this.docTokens.keys()) {
+                results.push({ id: id, score: 0 });
+            }
+            return results;
+        }
+        // Egyedi query-termek halmaza (ismetlodes nem ad nagyobb IDF-et)
+        const uniqueTerms = Array.from(new Set(queryTokens));
+        // Pre-compute IDF a query-termekre
+        const idfMap = new Map();
+        for (const term of uniqueTerms) {
+            const df = this.termDocFreq.get(term) ?? 0;
+            // BM25+ IDF: log((N - df + 0.5) / (df + 0.5) + 1)
+            const idf = Math.log((this.docCount - df + 0.5) / (df + 0.5) + 1);
+            idfMap.set(term, idf);
+        }
+        // Per-doc BM25 score
+        const results = [];
+        for (const [docId, docLen] of this.docLengths) {
+            let score = 0;
+            for (const term of uniqueTerms) {
+                const tf = this.termFreqByDoc.get(term)?.get(docId) ?? 0;
+                if (tf === 0) {
+                    continue;
+                }
+                const idf = idfMap.get(term) ?? 0;
+                const norm = 1 - BM25_B + BM25_B * (docLen / (this.avgDocLength || 1));
+                score += idf * (tf * (BM25_K1 + 1)) / (tf + BM25_K1 * norm);
+            }
+            results.push({ id: docId, score: score });
+        }
+        return results;
+    }
+}
+exports.DyNTS_LVS_BM25_Corpus = DyNTS_LVS_BM25_Corpus;
+/**
+ * Min-max normalizalas [0,1] tartomanyra. A hybrid score-merge-hez kell a BM25
+ * score-okat a candidate-szetten 0..1 sav-ba hozni (a cosine mar 0..1).
+ *
+ * Edge case-ek:
+ *  - Ures array → [].
+ *  - Minden score azonos (max-min === 0) → minden 0.0 (NEM 0.5 vagy 1.0; ha
+ *    nincs diszkriminacio, ne tegyunk hozza signal-t).
+ *  - Negativ score-ok (BM25+IDF garantal pozitivat, de defensive): a min-max
+ *    ugyanugy mukodik.
+ */
+function dyNTS_LVS_BM25_minMaxNormalize(scores) {
+    if (!Array.isArray(scores) || scores.length === 0) {
+        return [];
+    }
+    let min = Infinity;
+    let max = -Infinity;
+    for (const s of scores) {
+        if (s.score < min) {
+            min = s.score;
+        }
+        if (s.score > max) {
+            max = s.score;
+        }
+    }
+    const range = max - min;
+    if (range === 0) {
+        // Nincs diszkriminacio — minden 0.0 (NEM huzzon le, NEM huzzon fel)
+        return scores.map((s) => ({
+            id: s.id, score: 0,
+        }));
+    }
+    return scores.map((s) => ({
+        id: s.id,
+        score: (s.score - min) / range,
+    }));
+}
 //# sourceMappingURL=lvs-bm25.util.js.map

package/build/_modules/local-vector-search/_services/lvs-doc-chunk-data.service.d.ts

@@ -1,27 +1,27 @@
-import { DyFM_DataModel_Params } from '@futdevpro/fsm-dynamo';
-import { DyFM_OAI_Settings } from '@futdevpro/fsm-dynamo/ai/open-ai';
-import { DyNTS_LVS_VectorDataService } from './lvs-local-vector-search.data-service';
-import { DyNTS_DAI_DocChunk } from '../../ai/_modules/document-ai/_models/data-models/dai-doc-chunk.data-model';
-import { DyNTS_DAI_DocPage } from '../../ai/_modules/document-ai/_models/data-models/dai-doc-page.data-model';
-import { DyNTS_DAI_Document } from '../../ai/_modules/document-ai/_models/data-models/dai-document.data-model';
-import { DyNTS_OAI_DocumentDataService } from '../../ai/_modules/open-ai/_services/data-services/oai-document.data-service';
-import { DyNTS_OAI_DocPageDataService } from '../../ai/_modules/open-ai/_services/data-services/oai-doc-page.data-service';
-import { DyNTS_DAI_DocChunkCompareResult } from '../../ai/_modules/document-ai/_models/interfaces/dai-doc-chunk-compare-result.interface';
-/**
- * Local Doc Chunk Data Service
- * Extends {@link DyNTS_LVS_VectorDataService} to provide document chunking functionality
- * with local in-memory vector search instead of MongoDB vector search
- */
-export declare class DyNTS_LVS_DocChunkDataService<T_Chunk extends DyNTS_DAI_DocChunk = DyNTS_DAI_DocChunk, T_Page extends DyNTS_DAI_DocPage<T_Chunk> = DyNTS_DAI_DocPage<T_Chunk>, T_ExternalDocumentId = string, T_Document extends DyNTS_DAI_Document<T_Chunk, T_Page, T_ExternalDocumentId> = DyNTS_DAI_Document<T_Chunk, T_Page, T_ExternalDocumentId>> extends DyNTS_LVS_VectorDataService<T_Chunk> {
-    clickupWorkspaceId: string;
-    constructor(issuer: string, openAiSettings: DyFM_OAI_Settings, dataParams?: DyFM_DataModel_Params<T_Chunk>);
-    getDocumentDataService(): DyNTS_OAI_DocumentDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document>;
-    getDocPageDataService(): DyNTS_OAI_DocPageDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document>;
-    processPage(page: T_Page): Promise<DyNTS_DAI_DocChunkCompareResult<T_Chunk>[]>;
-    processNewPage(page: T_Page): Promise<DyNTS_DAI_DocChunkCompareResult<T_Chunk>[]>;
-    compareChunk(newChunk: T_Chunk, oldChunk: T_Chunk): Promise<DyNTS_DAI_DocChunkCompareResult<T_Chunk>>;
-    private compareStringArrays;
-    chunkPage(page: T_Page): Promise<T_Chunk[]>;
-    getPageLink(page: T_Page): string;
-}
+import { DyFM_DataModel_Params } from '@futdevpro/fsm-dynamo';
+import { DyFM_OAI_Settings } from '@futdevpro/fsm-dynamo/ai/open-ai';
+import { DyNTS_LVS_VectorDataService } from './lvs-local-vector-search.data-service';
+import { DyNTS_DAI_DocChunk } from '../../ai/_modules/document-ai/_models/data-models/dai-doc-chunk.data-model';
+import { DyNTS_DAI_DocPage } from '../../ai/_modules/document-ai/_models/data-models/dai-doc-page.data-model';
+import { DyNTS_DAI_Document } from '../../ai/_modules/document-ai/_models/data-models/dai-document.data-model';
+import { DyNTS_OAI_DocumentDataService } from '../../ai/_modules/open-ai/_services/data-services/oai-document.data-service';
+import { DyNTS_OAI_DocPageDataService } from '../../ai/_modules/open-ai/_services/data-services/oai-doc-page.data-service';
+import { DyNTS_DAI_DocChunkCompareResult } from '../../ai/_modules/document-ai/_models/interfaces/dai-doc-chunk-compare-result.interface';
+/**
+ * Local Doc Chunk Data Service
+ * Extends {@link DyNTS_LVS_VectorDataService} to provide document chunking functionality
+ * with local in-memory vector search instead of MongoDB vector search
+ */
+export declare class DyNTS_LVS_DocChunkDataService<T_Chunk extends DyNTS_DAI_DocChunk = DyNTS_DAI_DocChunk, T_Page extends DyNTS_DAI_DocPage<T_Chunk> = DyNTS_DAI_DocPage<T_Chunk>, T_ExternalDocumentId = string, T_Document extends DyNTS_DAI_Document<T_Chunk, T_Page, T_ExternalDocumentId> = DyNTS_DAI_Document<T_Chunk, T_Page, T_ExternalDocumentId>> extends DyNTS_LVS_VectorDataService<T_Chunk> {
+    clickupWorkspaceId: string;
+    constructor(issuer: string, openAiSettings: DyFM_OAI_Settings, dataParams?: DyFM_DataModel_Params<T_Chunk>);
+    getDocumentDataService(): DyNTS_OAI_DocumentDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document>;
+    getDocPageDataService(): DyNTS_OAI_DocPageDataService<T_Chunk, T_Page, T_ExternalDocumentId, T_Document>;
+    processPage(page: T_Page): Promise<DyNTS_DAI_DocChunkCompareResult<T_Chunk>[]>;
+    processNewPage(page: T_Page): Promise<DyNTS_DAI_DocChunkCompareResult<T_Chunk>[]>;
+    compareChunk(newChunk: T_Chunk, oldChunk: T_Chunk): Promise<DyNTS_DAI_DocChunkCompareResult<T_Chunk>>;
+    private compareStringArrays;
+    chunkPage(page: T_Page): Promise<T_Chunk[]>;
+    getPageLink(page: T_Page): string;
+}
 //# sourceMappingURL=lvs-doc-chunk-data.service.d.ts.map