@futdevpro/nts-dynamo 1.15.157 → 1.15.160

package/src/_modules/local-vector-search/_services/lvs-vector-pool.control-service.ts

@@ -1,323 +0,0 @@
-import { DyFM_Log } from '@futdevpro/fsm-dynamo';
-
-import { LVS_Search_Mode } from '../_enums/lvs-search-mode.enum';
-import { LVS_SearchResult } from '../_models/lvs-search-result.interface';
-
-/**
- * Vektor pool kezelő utility class
- * Instance-based class, amely in-memory vektor pool-t kezel és vektor hasonlósági számításokat végez
- * Minden instance saját vektor pool-t tart fenn
- */
-export class LVS_VectorPool_ControlService {
-  /**
-   * In-memory vektor pool tárolás
-   * Key: vektor ID, Value: vektor értékek
-   *
-   * BFR-AM-013 (Tier-1 memória): a belső tárolás `Float32Array` (4 byte/elem, boxing nélkül) a
-   * korábbi `number[]` (8 byte + array-boxing) helyett → ~2–4× kisebb PERSISTENS pool-footprint
-   * (2560-dim × 32k vektornál a heap érdemi része). A cosine/l2 index-alapú loopjai változatlanul
-   * futnak rajta; a publikus `getAll()` kontraktja (number[]) konverzióval megőrzött.
-   */
-  private vectorPool: Map<string, Float32Array> = new Map<string, Float32Array>();
-
-  /**
-   * Normalizált vektor pool tárolás (L2 normalizált másolatok)
-   * Key: vektor ID, Value: L2 normalizált vektor értékek (Float32Array — l. fent)
-   */
-  private normalizedVectorPool: Map<string, Float32Array> = new Map<string, Float32Array>();
-
-  /**
-   * `normalizedOnly` mód: ha `true`, a pool NEM tárolja a nyers vektorokat (`vectorPool`) — CSAK a
-   * normalizált másolatot. A kizárólag-cosine fogyasztóknak (pl. RAG-keresés) ez ~50% memória-megtakarítás
-   * (a két párhuzamos pool helyett egy). Ekkor az `l2Distance`-keresés és a `getAll()` nyers-érték-olvasása
-   * N/A (a `size()` + a `cosineSimilarity`-keresés továbbra is helyes). Default `false` (visszafelé kompatibilis).
-   */
-  private readonly normalizedOnly: boolean;
-
-  constructor(set?: { normalizedOnly?: boolean }) {
-    this.normalizedOnly = set?.normalizedOnly ?? false;
-  }
-
-  /**
-   * Hozzáad egy vektort a pool-hoz
-   * Opcionálisan L2 normalizált másolatot is tárol
-   */
-  addVector(id: string, vector: number[]): void {
-    if (!id) {
-      throw new Error('Vector ID is required');
-    }
-
-    if (!Array.isArray(vector) || vector.length === 0) {
-      throw new Error('Vector must be a non-empty array');
-    }
-
-    // Validáljuk, hogy a vektor számokból áll
-    for (let i: number = 0; i < vector.length; i++) {
-      if (typeof vector[i] !== 'number' || !isFinite(vector[i])) {
-        throw new Error(`Vector must contain only finite numbers at index ${i}`);
-      }
-    }
-
-    // Tároljuk az eredeti vektort — KIVÉVE normalizedOnly módban (akkor a nyers pool kihagyva, ~50% memória).
-    // Float32Array-ként (BFR-AM-013 Tier-1) — a number[]-boxing nélkül.
-    if (!this.normalizedOnly) {
-      this.vectorPool.set(id, Float32Array.from(vector));
-    }
-
-    // L2 normalizált másolatot is tárolunk a cosine similarity számításokhoz
-    this.normalizedVectorPool.set(id, LVS_VectorPool_ControlService.l2NormalizeFloat32(vector));
-  }
-
-  /**
-   * Eltávolít egy vektort a pool-ból
-   */
-  removeVector(id: string): void {
-    this.vectorPool.delete(id);
-    this.normalizedVectorPool.delete(id);
-  }
-
-  /**
-   * Frissít egy vektort a pool-ban
-   */
-  updateVector(id: string, vector: number[]): void {
-    // A `normalizedVectorPool` a forrás (mindkét módban populált; `normalizedOnly`-ban a `vectorPool` üres).
-    if (!this.normalizedVectorPool.has(id)) {
-      throw new Error(`Vector with ID "${id}" does not exist`);
-    }
-
-    this.addVector(id, vector);
-  }
-
-  /**
-   * A pool elemszáma. Mindkét módban helyes (a `normalizedVectorPool` a forrás), így `normalizedOnly`
-   * módban is — szemben a `getAll().size`-szal, ami ott üres (a nyers pool nincs tárolva).
-   */
-  size(): number {
-    return this.normalizedVectorPool.size;
-  }
-
-  /**
-   * Törli az összes vektort a pool-ból
-   */
-  clearPool(): void {
-    this.vectorPool.clear();
-    this.normalizedVectorPool.clear();
-  }
-
-  /**
-   * Visszaadja az összes vektort a pool-ból
-   * Debugging és export céljára
-   */
-  getAll(): Map<string, number[]> {
-    // A publikus kontrakt (number[]) megőrzése — a belső Float32Array-ből konvertálva.
-    const result: Map<string, number[]> = new Map<string, number[]>();
-    for (const [ id, vector ] of this.vectorPool.entries()) {
-      result.set(id, Array.from(vector));
-    }
-    return result;
-  }
-
-  /**
-   * BFR-AM-013 (Tier-1): L2-normalizálás Float32Array-be, explicit loopokkal (allokáció-minimális) —
-   * a pool BELSŐ tárolási formátumához. Nullvektor → csupa-0 Float32Array.
-   */
-  private static l2NormalizeFloat32(vector: ArrayLike<number>): Float32Array {
-    let sumSquares: number = 0;
-    for (let i: number = 0; i < vector.length; i++) {
-      sumSquares += vector[i] * vector[i];
-    }
-    const magnitude: number = Math.sqrt(sumSquares);
-
-    const normalized: Float32Array = new Float32Array(vector.length);
-    if (magnitude === 0) {
-      return normalized;
-    }
-    for (let i: number = 0; i < vector.length; i++) {
-      normalized[i] = vector[i] / magnitude;
-    }
-    return normalized;
-  }
-
-  /**
-   * L2 normalizálás egy vektorra
-   * A vektor hosszát 1-re normalizálja
-   * Statikus metódus, mivel nincs szüksége instance state-re
-   */
-  private static l2Normalize(vector: number[]): number[] {
-    const magnitude: number = Math.sqrt(
-      vector.reduce((sum: number, value: number) => sum + value * value, 0)
-    );
-
-    if (magnitude === 0) {
-      // Ha a vektor nullvektor, akkor nullvektort adunk vissza
-      return new Array<number>(vector.length).fill(0);
-    }
-
-    return vector.map((value: number) => value / magnitude);
-  }
-
-  /**
-   * Cosine similarity számítás két vektor között
-   * Normalizált vektorokat használ a számításhoz
-   * Eredmény: 0 és 1 közötti érték, ahol 1 a legnagyobb hasonlóság
-   * Statikus metódus, mivel nincs szüksége instance state-re
-   */
-  static cosineSimilarity(a: number[], b: number[]): number {
-    if (a.length !== b.length) {
-      throw new Error(
-        `Vectors must have the same dimension. Got ${a.length} and ${b.length}`
-      );
-    }
-
-    // Normalizáljuk a vektorokat
-    const normalizedA: number[] = this.l2Normalize(a);
-    const normalizedB: number[] = this.l2Normalize(b);
-
-    // Dot product számítása
-    let dotProduct: number = 0;
-    for (let i: number = 0; i < normalizedA.length; i++) {
-      dotProduct += normalizedA[i] * normalizedB[i];
-    }
-
-    // Cosine similarity = dot product of normalized vectors
-    // Mivel a vektorok normalizáltak, ez egyenlő a cosine similarity-vel
-    return dotProduct;
-  }
-
-  /**
-   * L2 distance (Euklideszi távolság) számítás két vektor között
-   * Eredmény: 0 vagy pozitív érték, ahol 0 a legkisebb távolság
-   * Statikus metódus, mivel nincs szüksége instance state-re
-   */
-  static l2Distance(a: ArrayLike<number>, b: ArrayLike<number>): number {
-    if (a.length !== b.length) {
-      throw new Error(
-        `Vectors must have the same dimension. Got ${a.length} and ${b.length}`
-      );
-    }
-
-    // L2 distance = sqrt(sum((a[i] - b[i])^2))
-    let sumSquaredDiff: number = 0;
-    for (let i: number = 0; i < a.length; i++) {
-      const diff: number = a[i] - b[i];
-      sumSquaredDiff += diff * diff;
-    }
-
-    return Math.sqrt(sumSquaredDiff);
-  }
-
-  /**
-   * Vektor keresés a pool-ban
-   * Brute-force megközelítés (lineáris keresés)
-   * 
-   * @param query A keresési query vektor
-   * @param k A visszaadandó találatok száma (top-K)
-   * @param mode A keresési mód (cosine similarity vagy L2 distance)
-   * @param candidateIds Opcionális jelölt-ID szűrő: ha meg van adva, a keresés CSAK az ebben a
-   *   halmazban lévő ID-kra fut (a többit `Set.has` O(1)-gyel kihagyja). Így a hívónak NEM kell külön
-   *   szűkített pool-t építenie + a vektorokat újra-normalizálnia — a keresés a MÁR előre-normalizált
-   *   `normalizedVectorPool`-on iterál allokáció-mentesen. Üres halmaz → üres eredmény.
-   * @returns A top-K találatok ID-val és score-rel, megfelelő sorrendben
-   */
-  search(
-    query: number[],
-    k: number,
-    mode: LVS_Search_Mode,
-    candidateIds?: Set<string>
-  ): LVS_SearchResult[] {
-    // Üres jelölt-halmaz → nincs mit keresni (a `undefined` viszont „nincs szűrés" = teljes pool).
-    if (candidateIds && candidateIds.size === 0) {
-      return [];
-    }
-    if (!Array.isArray(query) || query.length === 0) {
-      throw new Error('Query vector must be a non-empty array');
-    }
-
-    // BFR-AM-013 (NaN/±Inf-guard): nem-véges query-elem NÉMÁN mérgezné a TELJES rangsort
-    // (minden dot-product NaN → a valódi találatok kiesnek, hiba nélkül) → fail-closed throw.
-    for (let i: number = 0; i < query.length; i++) {
-      if (!Number.isFinite(query[i])) {
-        throw new Error(`Query vector must contain only finite numbers (non-finite at index ${i})`);
-      }
-    }
-
-    if (k <= 0) {
-      throw new Error('k must be a positive number');
-    }
-
-    // `normalizedOnly` módban nincs nyers pool → l2Distance nem számolható (csak cosine).
-    if (this.normalizedOnly && mode === LVS_Search_Mode.l2Distance) {
-      throw new Error('l2Distance search is not available in normalizedOnly mode (raw vectors are not stored)');
-    }
-
-    // Üres pool → üres eredmény. A `normalizedVectorPool` a forrás (mindkét módban populált; a nyers
-    // `vectorPool` `normalizedOnly`-ban üres, ezért NEM azon ellenőrzünk).
-    if (this.normalizedVectorPool.size === 0) {
-      return [];
-    }
-
-    // Validáljuk, hogy minden vektor ugyanolyan dimenziójú-e. A referencia-pool mód-függő: l2 a nyers,
-    // cosine a normalizált (azonos dimenzió, de `normalizedOnly`-ban a nyers pool üres).
-    const referencePool: Map<string, Float32Array> =
-      mode === LVS_Search_Mode.l2Distance ? this.vectorPool : this.normalizedVectorPool;
-    const firstVector: Float32Array | undefined = referencePool.values().next().value;
-    if (firstVector && firstVector.length !== query.length) {
-      throw new Error(
-        `Query vector dimension (${query.length}) does not match pool vector ` +
-        `dimension (${firstVector.length})`
-      );
-    }
-
-    // Számoljuk ki a hasonlóságot/távolságot minden vektorra
-    const results: LVS_SearchResult[] = [];
-
-    if (mode === LVS_Search_Mode.cosineSimilarity) {
-      // PERF (BFR-AM-013): a query-t EGYSZER normalizáljuk, majd dot-product a MÁR ELŐRE eltárolt
-      // `normalizedVectorPool` (l2-normalizált) vektorok ellen. Eredmény AZONOS a régi
-      // `cosineSimilarity(query, vector)`-ral (= dot(norm(q), norm(v))), de:
-      //  (1) NEM normalizáljuk újra MINDEN vektort MINDEN keresésnél (a normalizálás a `addVector`-ban
-      //      egyszer megtörtént) → ~3× kevesebb FLOP;
-      //  (2) a per-összehasonlítás dot-product ALLOKÁCIÓ-MENTES (a régi `l2Normalize` hívásonként KÉT új
-      //      tömböt allokált → egy 24k-vektoros keresés ~48k tömb-allokáció + GC-spike-ot okozott).
-      // A drágán eltárolt `normalizedVectorPool` korábban SOHA nem volt használva a keresésben.
-      const queryNormalized: Float32Array = LVS_VectorPool_ControlService.l2NormalizeFloat32(query);
-      // BFR-AM-013 (NaN-guard, defensive): ha egy tárolt vektor mégis NaN-score-t adna (elvileg az
-      // addVector-guard kizárja), a találat KIESIK — nem mérgezi a rangsort — és warn-t adunk (nem néma).
-      let nanScoreCount: number = 0;
-      for (const [id, normalizedVector] of this.normalizedVectorPool.entries()) {
-        if (candidateIds && !candidateIds.has(id)) {
-          continue;
-        }
-        let dotProduct: number = 0;
-        for (let i: number = 0; i < queryNormalized.length; i++) {
-          dotProduct += queryNormalized[i] * normalizedVector[i];
-        }
-        if (!Number.isFinite(dotProduct)) {
-          nanScoreCount++;
-          continue;
-        }
-        results.push({ id, score: dotProduct });
-      }
-      if (nanScoreCount) {
-        DyFM_Log.warn(`[LVS search] ${nanScoreCount} vector(s) produced non-finite scores and were skipped.`);
-      }
-      // Cosine similarity: csökkenő sorrend (legnagyobb hasonlóság először)
-      results.sort((a: LVS_SearchResult, b: LVS_SearchResult) => b.score - a.score);
-    } else if (mode === LVS_Search_Mode.l2Distance) {
-      for (const [id, vector] of this.vectorPool.entries()) {
-        if (candidateIds && !candidateIds.has(id)) {
-          continue;
-        }
-        results.push({ id, score: LVS_VectorPool_ControlService.l2Distance(query, vector) });
-      }
-      // L2 distance: növekvő sorrend (legkisebb távolság először)
-      results.sort((a: LVS_SearchResult, b: LVS_SearchResult) => a.score - b.score);
-    } else {
-      throw new Error(`Unknown search mode: ${mode}`);
-    }
-
-    // Visszaadjuk a top-K találatot
-    return results.slice(0, k);
-  }
-}
-

package/src/_modules/local-vector-search/index.ts

@@ -1,17 +0,0 @@
-
-
-// ENUMS
-export * from './_enums/lvs-search-mode.enum';
-
-// INTERFACES
-export * from './_models/lvs-search-result.interface';
-
-// DATA MODELS
-export * from './_models/data-models/lvs-vector-persist.data-model';
-
-// SERVICES
-export * from './_services/lvs-doc-chunk-data.service';
-export * from './_services/lvs-local-vector-search.data-service';
-export * from './_services/lvs-vector-pool.control-service';
-export * from './_services/lvs-vector-persist.data-service';
-export * from './_services/lvs-persistent-vector-pool.control-service';

package/src/_modules/logs/_models/file-log-entry.interface.ts

@@ -1,13 +0,0 @@
-/**
- * Egy log fajl meta-adata a listazasban.
- */
-export interface DyNTS_FileLog_Entry {
-  /** Fajlnev (csak basename — NEM teljes path). */
-  name: string;
-  /** Fajlmeret byte-ban. */
-  sizeBytes: number;
-  /** Modositasi ido ms-ban (mtimeMs). */
-  mtimeMs: number;
-  /** Igaz, ha ez az aktualis aktiv session fajlja. */
-  isCurrent: boolean;
-}

package/src/_modules/logs/_models/file-log-read-result.interface.ts

@@ -1,37 +0,0 @@
-/**
- * `readLogFile()` valaszobjektum.
- */
-export interface DyNTS_FileLog_ReadResult {
-  /** Fajlnev (csak basename). */
-  name: string;
-  /** Teljes fajlmeret byte-ban. */
-  sizeBytes: number;
-  /** A fajlban talalhato osszes sor szama. */
-  totalLines: number;
-  /** A visszaadott sorok. */
-  lines: string[];
-  /** Mod amiben olvastunk: 'tail' | 'head' | 'range'. */
-  mode: 'tail' | 'head' | 'range';
-  /** Visszaadott tartomany 1-based start (range/tail/head normalizalva). */
-  rangeStart: number;
-  /** Visszaadott tartomany 1-based end (inclusive). */
-  rangeEnd: number;
-}
-
-
-/**
- * `readLogFile(name, options)` opciok.
- *
- * Egyetlen mod aktiv egyszerre. Prioritas: range > head > tail.
- * Egyik sem megadott → default `tail: 200`.
- */
-export interface DyNTS_FileLog_ReadOptions {
-  /** Utolso N sor (default mod ha semmi mas nincs). */
-  tail?: number;
-  /** Elso N sor. */
-  head?: number;
-  /** 1-based line range start (inclusive). `rangeEnd` is kell. */
-  rangeStart?: number;
-  /** 1-based line range end (inclusive). */
-  rangeEnd?: number;
-}