@futdevpro/fdp-agent-memory 0.1.0

package/build/src/_collections/fam-error-context.util.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ErrorContext_Util = void 0;
+/**
+ * `FAM_ErrorContext_Util` (dsgn-008 §6, SP-8.1) — statikus, **függőség-mentes** util a hiba-kontextus
+ * (`contextSnapshot`) normalizálásához. A hívó réteg nyers kontextusát (`FAM_ErrorContextInput`) a
+ * `FAM_ErrorContext` shape-re hozza:
+ *
+ * - **scope-lánc → string:** ha a `scopePath` `string[]` (canonical-nevek), `">"`-tal láncolja
+ *   (`"org>project>module"`); ha már string, változatlan.
+ * - **üres-kihagyás:** csak a jelenlévő mezőket írja be — a snapshot sosem hordoz üres/`undefined`
+ *   zajt, de **sosem üres, ha a kontextus elérhető** (a snapshot összeállítás a hiba-kibocsátás
+ *   kötelező része, dsgn-008 §4).
+ * - **sensitive-kiszűrés (HARD, dsgn-008 §6):** API-key / token / secret / password / bearer SOHA
+ *   nem kerül a snapshot-ba. A snapshot mező-halmaza fix (`FAM_ErrorContext`), így a kiszűrés a
+ *   string-mezők értékeit is védi (egy gyanús-mintára illeszkedő érték `'[redacted]'`).
+ */
+class FAM_ErrorContext_Util {
+    /** Sensitive-kulcs/érték minták (case-insensitive) — a snapshot SOHA nem hordozhat ilyet. */
+    static SENSITIVE_PATTERN = /(api[-_]?key|secret|token|password|passwd|bearer|authorization|private[-_]?key|access[-_]?key)/i;
+    /**
+     * A nyers kontextusból a normalizált `FAM_ErrorContext` snapshot. Csak a jelenlévő mezőket
+     * írja be; a `scopePath` tömböt láncolja; a string-értékeket sensitive-szűri. Ha a bemenet
+     * üres/hiányzik, `undefined`-et ad (a hiba-rekordon nem lesz `contextSnapshot`).
+     */
+    static build(input) {
+        if (!input) {
+            return undefined;
+        }
+        const snapshot = {};
+        FAM_ErrorContext_Util.setString(snapshot, 'instanceId', input.instanceId);
+        FAM_ErrorContext_Util.setString(snapshot, 'runId', input.runId);
+        FAM_ErrorContext_Util.setScopePath(snapshot, input.scopePath);
+        FAM_ErrorContext_Util.setTable(snapshot, input.table);
+        FAM_ErrorContext_Util.setString(snapshot, 'operation', input.operation);
+        FAM_ErrorContext_Util.setString(snapshot, 'sourceFilePath', input.sourceFilePath);
+        FAM_ErrorContext_Util.setNumber(snapshot, 'chunkIndex', input.chunkIndex);
+        FAM_ErrorContext_Util.setString(snapshot, 'query', input.query);
+        FAM_ErrorContext_Util.setString(snapshot, 'provider', input.provider);
+        // Ha minden mező hiányzott, NINCS snapshot (a rekordon nem jelenik meg üres objektum).
+        return Object.keys(snapshot).length ? snapshot : undefined;
+    }
+    /**
+     * Egy szabad kulcs sensitive-e (a hívók is használhatják, pl. egy `additionalContent`-szerű
+     * objektum kulcs-szűréséhez a hiba-kibocsátás előtt). A `value` is vizsgált (egy nem-sensitive
+     * kulcson is lehet pl. teljes connection-string).
+     */
+    static isSensitive(key, value) {
+        if (FAM_ErrorContext_Util.SENSITIVE_PATTERN.test(key)) {
+            return true;
+        }
+        if (typeof value === 'string' && FAM_ErrorContext_Util.SENSITIVE_PATTERN.test(value)) {
+            return true;
+        }
+        return false;
+    }
+    /** String-mező beállítás üres-kihagyással + sensitive-redakcióval. */
+    static setString(snapshot, key, value) {
+        if (value === undefined || value === null || value === '') {
+            return;
+        }
+        const redacted = FAM_ErrorContext_Util.SENSITIVE_PATTERN.test(value) ? '[redacted]' : value;
+        snapshot[key] = redacted;
+    }
+    /** Number-mező beállítás (a 0 érvényes érték — csak az `undefined`/`null` kihagyott). */
+    static setNumber(snapshot, key, value) {
+        if (value === undefined || value === null || Number.isNaN(value)) {
+            return;
+        }
+        snapshot[key] = value;
+    }
+    /** A `table` enum beállítás (üres-kihagyással). */
+    static setTable(snapshot, value) {
+        if (value === undefined || value === null) {
+            return;
+        }
+        snapshot.table = value;
+    }
+    /** A scope-lánc normalizálás: `string[]` → `">"`-láncolt string; string → változatlan. */
+    static setScopePath(snapshot, value) {
+        if (value === undefined || value === null) {
+            return;
+        }
+        const chained = Array.isArray(value) ? value.filter(Boolean).join('>') : value;
+        if (chained) {
+            snapshot.scopePath = chained;
+        }
+    }
+}
+exports.FAM_ErrorContext_Util = FAM_ErrorContext_Util;

package/build/src/_collections/fam-error-factory.util.js

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_Error_Util = void 0;
+exports.createFamError = createFamError;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const error_codes_const_1 = require("./error-codes.const");
+const fam_error_context_util_1 = require("./fam-error-context.util");
+/**
+ * `FAM_Error_Util` (SP-8.2, dsgn-008 §4) — a réteg-szintű hiba-emisszió **reusable factory**-ja. NEM
+ * persistál és NEM kapja el a hibát — csak megépíti a kanonikus `DyFM_Error`-t (errorCode + level +
+ * `contextSnapshot`), amit a réteg vagy dob (a `globalErrorHandler` perzistálja), vagy a
+ * `FAM_Error_ControlService.emit`-en át küld. Így minden réteg UGYANAZT a hiba-shape-et bocsátja ki
+ * (a 3-lépéses szerződés 1. lépése), nem ad-hoc `new DyFM_Error`-t szór szét.
+ *
+ * A `level` default a `<SVC>` réteg-kódból (a `errorCode` első szegmense után), a katalógus
+ * `FAM_ERROR_SVC_DEFAULT_LEVEL` map-jéből — így a réteg-MP-knek nem kell ismételten level-t adni.
+ *
+ * A `contextSnapshot` a `DyFM_Error.additionalContent.contextSnapshot`-ba kerül (a Dynamo-record
+ * `createErrorRecord` az `additionalContent`-et viszi át), majd a `FAM_Error_DataService` emeli a
+ * rekord top-level `contextSnapshot` mezőjébe (dsgn-008 §2).
+ */
+class FAM_Error_Util {
+    /**
+     * A kanonikus FAM `DyFM_Error` megépítése (errorCode + level + sensitive-szűrt snapshot). A
+     * `level` a megadott érték VAGY a `<SVC>` réteg-default. A `context` a `FAM_ErrorContext_Util`-on
+     * megy át (üres-kihagyás + sensitive-redakció). NEM dob, NEM persistál — a hívó dönti el.
+     */
+    static create(params) {
+        const level = params.level ?? FAM_Error_Util.defaultLevelForCode(params.errorCode);
+        const snapshot = fam_error_context_util_1.FAM_ErrorContext_Util.build(params.context);
+        return new fsm_dynamo_1.DyFM_Error({
+            errorCode: params.errorCode,
+            message: params.message,
+            level: level,
+            issuer: params.issuer,
+            issuerService: params.issuer,
+            error: params.cause,
+            // A snapshot az additionalContent-en utazik a Dynamo-record-ba (createErrorRecord viszi),
+            // majd a FAM_Error_DataService emeli a rekord top-level contextSnapshot mezőjébe.
+            additionalContent: snapshot ? { contextSnapshot: snapshot } : undefined,
+        });
+    }
+    /**
+     * A `<SVC>` réteg-default szint egy `FAM-<SVC>-<METHOD>-NNN` kódhoz (a katalógus map-jéből). A
+     * kód 2. szegmense a `<SVC>` (`FAM-EMB-PROVIDER-001` → `EMB`). Ismeretlen prefix → `error`.
+     */
+    static defaultLevelForCode(errorCode) {
+        const segments = (errorCode ?? '').split('-');
+        const svcSegment = segments[1];
+        const svc = Object.values(error_codes_const_1.FAM_ErrorSvc).includes(svcSegment ?? '')
+            ? svcSegment
+            : undefined;
+        return svc ? error_codes_const_1.FAM_ERROR_SVC_DEFAULT_LEVEL[svc] : fsm_dynamo_1.DyFM_ErrorLevel.error;
+    }
+}
+exports.FAM_Error_Util = FAM_Error_Util;
+/**
+ * Kényelmi factory-függvény (a `FAM_Error_Util.create` rövid alakja) — a réteg-MP-k ezt hívják a
+ * hiba-emisszió 1. lépéséhez. Pl.: `throw createFamError({ errorCode: FAM_ERROR_CODES.dbConnect,
+ * message: '...', context: { operation: 'connect' } })`.
+ */
+function createFamError(params) {
+    return FAM_Error_Util.create(params);
+}

package/build/src/_enums/fam-config-level.type-enum.js

@@ -0,0 +1,15 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ConfigLevel = void 0;
+/**
+ * Config feloldási-szint (dsgn-007 §2). A `level` + `tableScope` + `scopeId` hármas adja a
+ * `FAM_Config` feloldási kulcsát; a precedencia **scope > table > global > builtin** (dsgn-007 §3).
+ *
+ * Enum-konvenció (workspace base CLAUDE.md): a key camelCase, a value kebab/snake-case.
+ */
+var FAM_ConfigLevel;
+(function (FAM_ConfigLevel) {
+    FAM_ConfigLevel["global"] = "global";
+    FAM_ConfigLevel["table"] = "table";
+    FAM_ConfigLevel["scope"] = "scope";
+})(FAM_ConfigLevel || (exports.FAM_ConfigLevel = FAM_ConfigLevel = {}));

package/build/src/_enums/fam-table.type-enum.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_Table = void 0;
+/**
+ * Tár-azonosítók (dsgn-001 §1). A 6 fő RAG-tár + a `reference` helper-tár.
+ *
+ * Enum-konvenció (workspace base CLAUDE.md): a key camelCase, a value kebab/snake-case.
+ * A Mongo-collection naming `fam_<value>` (pl. `fam_rules`, `fam_coding_patterns`).
+ * A `reference` séma eltér a fő táraktól (dsgn-001 §5) — helper, NEM fő RAG-tár.
+ */
+var FAM_Table;
+(function (FAM_Table) {
+    FAM_Table["rules"] = "rules";
+    FAM_Table["documents"] = "documents";
+    FAM_Table["codebase"] = "codebase";
+    FAM_Table["knowledge"] = "knowledge";
+    FAM_Table["codingPatterns"] = "coding_patterns";
+    FAM_Table["memory"] = "memory";
+    FAM_Table["reference"] = "reference";
+})(FAM_Table || (exports.FAM_Table = FAM_Table = {}));

package/build/src/_integration-tests/_helpers/fam-integration-test-setup.util.js

@@ -0,0 +1,105 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_IntegrationTest_Setup_Util = void 0;
+const tslib_1 = require("tslib");
+const net = tslib_1.__importStar(require("net"));
+const mongoose_1 = tslib_1.__importDefault(require("mongoose"));
+const nts_dynamo_1 = require("@futdevpro/nts-dynamo");
+const fam_db_models_const_1 = require("../../_collections/fam-db-models.const");
+/** Integrációs teszt issuer — a MongoDB-dokumentumok azonosítására. */
+const INTTEST_ISSUER = 'integration-test';
+/** Teszt-adat prefix — a teszt-dokumentumok megkülönböztetésére (NEM ütközik production-nal). */
+const INTTEST_PREFIX = 'inttest-';
+/** A dedikált spec-DB neve (a runner/local Mongo-n; NEM a `fdp-agent-memory` prod-DB). */
+const INTTEST_DB_NAME = 'fam_inttest';
+/** MongoDB elérhetőség-ellenőrzés timeout (ms). */
+const MONGO_CHECK_TIMEOUT_MS = 1500;
+/**
+ * `FAM_IntegrationTest_Setup_Util` — az integrációs tesztek közös setup-utility-je (a
+ * `ccap-revisioned` `IntegrationTest_Setup_Util` mintára). MongoDB-elérhetőség (TCP-probe a
+ * `MONGO_URL`-re), egyedi `inttest-` ID-generálás, ÉS egy **lightweight DB-setup** (mongoose-connect +
+ * `DyNTS_GlobalService.setServices`) — **NEM a teljes `new App()` boot** (az HTTP-listen + LVS-hydrate
+ * postProcess-t indít, ami a spec-eket hangolja); csak a DataService-ek DB-rétegét állítja fel.
+ */
+class FAM_IntegrationTest_Setup_Util {
+    /** Teszt issuer azonosító — minden integrációs-teszt DataService-híváshoz. */
+    static getIssuer() {
+        return INTTEST_ISSUER;
+    }
+    /**
+     * Egyedi, időbélyeges ID/tartalom a teszt-adatokhoz. Pattern: `inttest-{timestamp}-{random}` —
+     * párhuzamos futtatásban is egyedi, és a prefix jelzi a teszt-adatot.
+     */
+    static generateUniqueId() {
+        const timestamp = Date.now();
+        const random = Math.random().toString(36).substring(2, 8);
+        return `${INTTEST_PREFIX}${timestamp}-${random}`;
+    }
+    /**
+     * MongoDB elérhetőség TCP-socket-tel (a `MONGO_URL` host:port-ja; default
+     * `mongodb://127.0.0.1:27017`). Ha nem elérhető → `false`, és a tesztek `pending()`-re állnak
+     * (CI-ben Mongo nélkül is zöld a suite — pending, NEM failure).
+     */
+    static checkMongoAvailability() {
+        return new Promise((resolve) => {
+            const mongoUrl = process.env.MONGO_URL ?? 'mongodb://127.0.0.1:27017';
+            const urlNoProtocol = mongoUrl.replace(/^mongodb(\+srv)?:\/\//, '');
+            const hostPort = urlNoProtocol.split('/')[0];
+            const parts = hostPort.split(':');
+            const host = parts[0];
+            const port = parseInt(parts[1] ?? '27017', 10);
+            const socket = net.createConnection({ host: host, port: port });
+            let finished = false;
+            const finish = (available) => {
+                if (finished) {
+                    return;
+                }
+                finished = true;
+                try {
+                    socket.destroy();
+                }
+                catch { /* ignore */ }
+                resolve(available);
+            };
+            socket.on('connect', () => { finish(true); });
+            socket.on('error', () => { finish(false); });
+            setTimeout(() => { finish(false); }, MONGO_CHECK_TIMEOUT_MS);
+        });
+    }
+    /**
+     * Lightweight DB-setup (`beforeAll`-ban, ha a Mongo elérhető): mongoose-connect a dedikált
+     * `fam_inttest` DB-re + `DyNTS_GlobalService.setServices` a `FAM_DB_MODELS`-szel (SSOT). Így a
+     * `new FAM_*_DataService(...)` (eager getDBService) feloldódik — App-boot, HTTP-listen és
+     * embedding/LVS-postProcess NÉLKÜL (azok a teljes boot velejárói, itt nem kellenek).
+     */
+    static async setupDb() {
+        const mongoUrl = process.env.MONGO_URL ?? 'mongodb://127.0.0.1:27017';
+        const base = mongoUrl.replace(/^(mongodb(\+srv)?:\/\/[^/]+).*$/, '$1');
+        await mongoose_1.default.connect(`${base}/${INTTEST_DB_NAME}`);
+        await nts_dynamo_1.DyNTS_GlobalService.setServices({ dbModels: fam_db_models_const_1.FAM_DB_MODELS });
+    }
+    /** DB-teardown (`afterAll`-ban): a mongoose-kapcsolat zárása (best-effort). */
+    static async teardownDb() {
+        try {
+            if (mongoose_1.default.connection.readyState !== 0) {
+                await mongoose_1.default.disconnect();
+            }
+        }
+        catch {
+            // best-effort — a process-vég úgyis bontja.
+        }
+    }
+    /** Egy collection ürítése teszt KÖZÖTT (a teszt-izolációhoz). No-op ha a kapcsolat nem áll. */
+    static async clearCollection(collectionName) {
+        if (mongoose_1.default.connection.readyState !== 1) {
+            return;
+        }
+        try {
+            await mongoose_1.default.connection.collection(collectionName).deleteMany({});
+        }
+        catch {
+            // a collection lehet hogy még nem létezik — nem hiba.
+        }
+    }
+}
+exports.FAM_IntegrationTest_Setup_Util = FAM_IntegrationTest_Setup_Util;

package/build/src/_models/data-models/fam-codebase.data-model.js

@@ -0,0 +1,51 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.famCodebase_dataParams = exports.FAM_Codebase_DataModel = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const fam_entry_base_properties_const_1 = require("./fam-entry-base-properties.const");
+const fam_entry_data_model_1 = require("./fam-entry.data-model");
+/**
+ * `codebase` tár (dsgn-001 §1/§4) — forráskód-chunkok (symbol / function / class / config …).
+ *
+ * A `FAM_Entry` bázisra épül; per-tár mezők: `parentSymbol`, `description` (JSDoc/komment),
+ * `requirementCodes`, `moduleSummary` (modul-összefoglaló chunk-e). `kind` default `'source'`.
+ */
+class FAM_Codebase_DataModel extends fam_entry_data_model_1.FAM_Entry {
+    /** A szülő-symbol (`FooClass` | `fooFunction`). */
+    parentSymbol;
+    /** JSDoc / komment a symbol-hoz. */
+    description;
+    /** Requirement-kódok (cross-search a `documents` tárral). */
+    requirementCodes = [];
+    /** Modul-összefoglaló chunk-e. */
+    moduleSummary;
+    constructor(set) {
+        super(set);
+        if (set) {
+            fsm_dynamo_1.DyFM_Object.cleanAssign(this, set);
+        }
+    }
+}
+exports.FAM_Codebase_DataModel = FAM_Codebase_DataModel;
+/**
+ * MongoDB data-params a `codebase` tárhoz (collection `fam_codebase`, dsgn-001 §1).
+ *
+ * `contentVector` `vectorizedFrom: ['content', 'description']` — a kód-chunk + a JSDoc/komment
+ * adja a vektorizált jelet (embedding-provider MP-2). `kind` default `'source'` (dsgn-001 §4).
+ */
+exports.famCodebase_dataParams = new fsm_dynamo_1.DyFM_DataModel_Params({
+    dataName: 'fam_codebase',
+    addArchive: true,
+    properties: {
+        ...fam_entry_base_properties_const_1.famEntryBaseProperties,
+        kind: { type: 'string', index: true, default: 'source' },
+        contentVector: {
+            type: 'number[]', vectorizedFrom: ['content', 'description'],
+            vectorizeUseIndex: 'contentVector', default: [],
+        },
+        parentSymbol: { type: 'string', index: true },
+        description: { type: 'string' },
+        requirementCodes: { type: 'string[]', index: true, default: [] },
+        moduleSummary: { type: 'boolean', index: true },
+    },
+});

package/build/src/_models/data-models/fam-coding-patterns.data-model.js

@@ -0,0 +1,58 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.famCodingPatterns_dataParams = exports.FAM_CodingPatterns_DataModel = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const fam_entry_base_properties_const_1 = require("./fam-entry-base-properties.const");
+const fam_entry_data_model_1 = require("./fam-entry.data-model");
+/**
+ * `coding_patterns` tár (dsgn-001 §1/§4) — coding-patterns / anti-patterns / recipes / template-ek.
+ *
+ * A `FAM_Entry` bázisra épül; per-tár mezők: `patternName`, `code` (a kód-snippet — **NEM** kerül
+ * a vektorba), `description`, `dimensions`. `kind` default `'pattern'`, `weight` default **5**
+ * (magas context-injection prioritás — CCAP-örökség, dsgn-001 §4).
+ */
+class FAM_CodingPatterns_DataModel extends fam_entry_data_model_1.FAM_Entry {
+    /** A pattern neve (rövid azonosító). */
+    patternName;
+    /** Code-snippet — a kódszöveg NEM kerül a vektorba (zajos szemantikus keresés). */
+    code;
+    /** Részletes magyarázat / kontextus / mikor használjuk. */
+    description;
+    /** Dimenziók (`server`|`client`|`fullstack`|`devops`|`testing`). */
+    dimensions = [];
+    /** Retrieval-scoring szorzó; default **5** (magas context-injection prioritás). */
+    weight = 5;
+    constructor(set) {
+        super(set);
+        if (set) {
+            fsm_dynamo_1.DyFM_Object.cleanAssign(this, set);
+        }
+    }
+}
+exports.FAM_CodingPatterns_DataModel = FAM_CodingPatterns_DataModel;
+/**
+ * MongoDB data-params a `coding_patterns` tárhoz (collection `fam_coding_patterns`, dsgn-001 §1).
+ *
+ * `contentVector` `vectorizedFrom: ['content', 'patternName', 'description']` — a `code` snippet
+ * SZÁNDÉKOSAN KIMARAD a vektorizált forrásból (dsgn-001 §4: a kódszöveg rontaná a szemantikus
+ * keresést). `kind` default `'pattern'`, `weight` default `5` (dsgn-001 §4). Embedding-provider MP-2.
+ */
+exports.famCodingPatterns_dataParams = new fsm_dynamo_1.DyFM_DataModel_Params({
+    dataName: 'fam_coding_patterns',
+    addArchive: true,
+    properties: {
+        ...fam_entry_base_properties_const_1.famEntryBaseProperties,
+        kind: { type: 'string', index: true, default: 'pattern' },
+        contentVector: {
+            type: 'number[]',
+            vectorizedFrom: ['content', 'patternName', 'description'],
+            vectorizeUseIndex: 'contentVector',
+            default: [],
+        },
+        weight: { type: 'number', default: 5 },
+        patternName: { type: 'string', index: true },
+        code: { type: 'string' },
+        description: { type: 'string' },
+        dimensions: { type: 'string[]', index: true, default: [] },
+    },
+});

package/build/src/_models/data-models/fam-config.data-model.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.famConfig_dataParams = exports.FAM_Config_DataModel = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+/**
+ * `FAM_Config` entitás (dsgn-007 §2). Egy dokumentum = **egy setting-érték egy adott szinten**;
+ * a `level` + `tableScope` + `scopeId` hármas adja a feloldási kulcsot (dsgn-007 §3 precedencia).
+ *
+ * `extends DyFM_Metadata` (NEM `FAM_Entry`): nem RAG-tartalom, hanem config-rekord. Az identitás/
+ * metadata (`_id`, `__created`, `__lastModified`, `_deleted`) az ősből jön; a `_deleted` soft-delete
+ * marker (Date), amit a `DyNTS_ArchiveDataService` kezel (a felülírás-history alapja, dsgn-007 §7.2).
+ *
+ * **Logikai unique-constraint** (dsgn-007 §2): `(level, tableScope, scopeId, key)` — egy szinten egy
+ * kulcsnak EGY aktív (`_deleted=false`) értéke van; új `set` ugyanarra felülír (régi soft-delete).
+ *
+ * A `value` szándékosan `unknown` (Mongoose `Mixed`, séma-szinten `type:'object'`): a típushelyesség
+ * a katalógus + a `set`-kori validáció felelőssége (dsgn-007 §7.1), nem a séma. A `value` írása
+ * **`$set`-tel atomikus** (Mongoose Mixed silent-drop ellen — memory: mongoose_mixed_atomic_write).
+ */
+class FAM_Config_DataModel extends fsm_dynamo_1.DyFM_Metadata {
+    // --- a feloldási kulcs ---
+    /** A feloldási-szint (`global`|`table`|`scope`). */
+    level;
+    /** `level='table'|'scope'` esetén kötelező: melyik tár. */
+    tableScope;
+    /** `level='scope'` esetén kötelező: a `FAM_Scope._id` (dsgn-002). */
+    scopeId;
+    // --- a setting maga ---
+    /** A katalógus kulcsa (§4) — pl. `'read.topK'` (string-ként perzistált). */
+    key;
+    /** A setting-érték; típusa a katalógus szerint (§4), validált (§7). Mongoose `Mixed`. */
+    value;
+    // --- audit (dsgn-007 §7) ---
+    /** Ki/mi állította be (`manual`/`agent`/`cli`/`ui`/`preset`/`env-seed`/`system`). */
+    setBy;
+    /** Beállítás-részlet (pl. preset-név `'openai-recommended'`, CLI-user). */
+    setByDetail;
+    /** Opcionális indoklás. */
+    note;
+    constructor(set) {
+        super(set);
+        if (set) {
+            fsm_dynamo_1.DyFM_Object.cleanAssign(this, set);
+        }
+    }
+}
+exports.FAM_Config_DataModel = FAM_Config_DataModel;
+/**
+ * MongoDB data-params a `fam_config` collection-höz (dsgn-007 §2). `addArchive: true` → a felülírt
+ * (régi) értékek soft-delete-elve megőrződnek (audit-trail / history, dsgn-007 §7.2).
+ *
+ * A `value` `type:'object'` (Mongoose `Mixed`) — séma NEM validál; a típushelyesség a katalógus +
+ * a `set`-kori validáció dolga (dsgn-007 §7.1).
+ */
+exports.famConfig_dataParams = new fsm_dynamo_1.DyFM_DataModel_Params({
+    dataName: 'fam_config',
+    addArchive: true,
+    properties: {
+        level: { type: 'string', index: true, required: true },
+        tableScope: { type: 'string', index: true },
+        scopeId: { type: 'string', index: true },
+        key: { type: 'string', index: true, required: true },
+        value: { type: 'object' },
+        setBy: { type: 'string', index: true },
+        setByDetail: { type: 'string' },
+        note: { type: 'string' },
+    },
+});

package/build/src/_models/data-models/fam-documents.data-model.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.famDocuments_dataParams = exports.FAM_Documents_DataModel = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+const fam_entry_base_properties_const_1 = require("./fam-entry-base-properties.const");
+const fam_entry_data_model_1 = require("./fam-entry.data-model");
+/**
+ * `documents` tár (dsgn-001 §1/§4) — dokumentumok (spec / dokumentáció / FR / bug / dev-note …).
+ *
+ * A `FAM_Entry` bázisra épül; per-tár mezők: `documentTitle`, `sourceType`, `sourceDocumentId`,
+ * `pageNumber`, `requirementCodes` (cross-search a `codebase`-szel). `kind` default `'document'`.
+ */
+class FAM_Documents_DataModel extends fam_entry_data_model_1.FAM_Entry {
+    /** A dokumentum címe. */
+    documentTitle;
+    /** Forrás-típus (`specification`|`documentation`|`fr`|`bug`|`other`). */
+    sourceType;
+    /** A forrás-dokumentum azonosítója. */
+    sourceDocumentId;
+    /** Oldalszám (ha lapozható forrás). */
+    pageNumber;
+    /** Requirement-kódok (cross-search a `codebase` tárral). */
+    requirementCodes = [];
+    constructor(set) {
+        super(set);
+        if (set) {
+            fsm_dynamo_1.DyFM_Object.cleanAssign(this, set);
+        }
+    }
+}
+exports.FAM_Documents_DataModel = FAM_Documents_DataModel;
+/**
+ * MongoDB data-params a `documents` tárhoz (collection `fam_documents`, dsgn-001 §1).
+ *
+ * `contentVector` `vectorizedFrom: ['content']` — auto-embed mentéskor (embedding-provider MP-2).
+ * `kind` default `'document'` (dsgn-001 §4).
+ */
+exports.famDocuments_dataParams = new fsm_dynamo_1.DyFM_DataModel_Params({
+    dataName: 'fam_documents',
+    addArchive: true,
+    properties: {
+        ...fam_entry_base_properties_const_1.famEntryBaseProperties,
+        kind: { type: 'string', index: true, default: 'document' },
+        contentVector: {
+            type: 'number[]', vectorizedFrom: ['content'], vectorizeUseIndex: 'contentVector', default: [],
+        },
+        documentTitle: { type: 'string', index: true },
+        sourceType: { type: 'string', index: true },
+        sourceDocumentId: { type: 'string', index: true },
+        pageNumber: { type: 'number' },
+        requirementCodes: { type: 'string[]', index: true, default: [] },
+    },
+});

package/build/src/_models/data-models/fam-entry-base-properties.const.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.famEntryBaseProperties = void 0;
+/**
+ * A `FAM_Entry` bázis-mezők közös `dataParams.properties` definíciója (dsgn-001 §2).
+ *
+ * A 6 fő tár `dataParams`-e ezt spread-eli (`...famEntryBaseProperties`), kiegészítve a
+ * per-tár specifikus mezőkkel (dsgn-001 §4) és a `contentVector` `vectorizedFrom` annotációval.
+ * Így a közös bázis-szótár EGY helyen él (SSOT), és a per-tár fájlok csak a delta-t tartalmazzák.
+ *
+ * A `contentVector` itt SZÁNDÉKOSAN NEM `vectorizedFrom`-annotált — azt minden tár a SAJÁT
+ * forrás-mezőivel deklarálja felül (pl. `knowledge`: `content` + `subject` + `description`),
+ * mert a vektorizált forrás-halmaz per-tár eltér (dsgn-001 §4, dsgn-006 §3). Az embedding-provider
+ * bekötése MP-2.
+ *
+ * Default-ok a `dataParams`-ban (nem csak TS-default), hogy a Mongo-perzistált rekordon is
+ * megjelenjenek (dsgn-001 §2: `embeddingStatus='pending'`, `weight`, `chunkIndex=0`, `tags=[]`).
+ */
+exports.famEntryBaseProperties = {
+    table: { type: 'string', index: true, required: true },
+    kind: { type: 'string', index: true },
+    tags: { type: 'string[]', index: true, default: [] },
+    content: { type: 'string', required: true },
+    contentVector: { type: 'number[]', default: [] },
+    contentHash: { type: 'string', index: true },
+    embeddingModel: { type: 'string' },
+    embeddingStatus: { type: 'string', index: true, default: 'pending' },
+    scopePath: { type: 'array', default: [] },
+    referenceLinks: { type: 'string[]', default: [] },
+    weight: { type: 'number', default: 1 },
+    importance: { type: 'number', index: true },
+    source: { type: 'object' },
+    sourceFilePath: { type: 'string', index: true },
+    chunkIndex: { type: 'number', index: true, default: 0 },
+    chunkTotal: { type: 'number' },
+    chunkType: { type: 'string', index: true },
+    position: { type: 'object' },
+    headingPath: { type: 'string[]', default: [] },
+    addedBy: { type: 'string', index: true },
+    ingestRunId: { type: 'string', index: true },
+    importSource: { type: 'string', index: true },
+    importSourceId: { type: 'string', index: true },
+};

package/build/src/_models/data-models/fam-entry.data-model.js

@@ -0,0 +1,81 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_Entry = void 0;
+const fsm_dynamo_1 = require("@futdevpro/fsm-dynamo");
+/**
+ * Egységes entry-bázis (dsgn-001 §2). Minden FŐ tár (rules…memory) bejegyzése ezt a
+ * shape-et követi, kiegészítve a per-tár specifikus mezőkkel (dsgn-001 §4).
+ *
+ * A `DyFM_Metadata`-ból öröklődik az identitás/metadata (`_id`, `__created`, `__lastModified`,
+ * `_deleted`) — EZEKET NEM duplikáljuk (dsgn-001 §2). A `_deleted` a Dynamo-ban soft-delete
+ * marker (`Date`); a `DyNTS_ArchiveDataService` kezeli (dsgn-001 §8).
+ *
+ * Nem önálló collection (nincs saját `dataParams`): a 6 fő DataModel terjeszti ki (SP-1.2).
+ * A `vectorizedFrom` annotáció (auto-embed mentéskor) a per-tár `dataParams.contentVector`-on
+ * deklarált — az embedding-provider bekötése MP-2 (itt csak a forrás-mező jelölése).
+ */
+class FAM_Entry extends fsm_dynamo_1.DyFM_Metadata {
+    // --- besorolás ---
+    /** Melyik tár (denormalizált, kötelező — write-validáció dsgn-001 §9.2). */
+    table;
+    /** Alap forma / fő jelleg (per-tár default, dsgn-001 §3/§4). */
+    kind;
+    /** Többes kategorizálás (dsgn-001 §3); per-tár ajánlott vokabulár, de szabadon bővül. */
+    tags = [];
+    // --- tartalom + embedding ---
+    /** A vektorizált, ember-olvasható szöveg (kanonikus mező — dsgn-001 §2). */
+    content;
+    /** Embedding-vektor (auto-fill mentéskor, dsgn-006 / MP-2). */
+    contentVector = [];
+    /** SHA-256(normalizált content) — delta-detection (dsgn-004 §4). */
+    contentHash;
+    /** Mely modell állította elő a vektort (per-tár/scope override a configból — dsgn-007). */
+    embeddingModel;
+    /** Embedding-állapot; default `'pending'` (a vektor-feltöltés MP-2). */
+    embeddingStatus = 'pending';
+    // --- scope (dinamikus lánc; dsgn-002) ---
+    /** Gyökér→levél canonical scope-entitás referenciák; write-on KÖTELEZŐ (dsgn-002 §3.2). */
+    scopePath = [];
+    /** Feloldott reference-entitás `_id`-k (alias/fogalom kapcsolat — dsgn-002 §3). */
+    referenceLinks = [];
+    // --- pontozás ---
+    /** Retrieval-score multiplikátor (`> 0`); `0` → kizárt. Default `1.0` (per-tár override). */
+    weight = 1;
+    /** Opcionális kvalitatív hangsúly (0..1). */
+    importance;
+    // --- forrás / pozíció (scan/import esetén) ---
+    /** Provenance (dsgn-001 §6). */
+    source;
+    /** Projekt-relatív útvonal (scan). */
+    sourceFilePath;
+    /** Chunk pozíció a forrásfájlon belül (0-alapú). */
+    chunkIndex = 0;
+    /** Összes chunk az adott forrásra. */
+    chunkTotal;
+    /**
+     * A chunk típusa:
+     * `'class'|'function'|'method'|'imports'|'interface'|'enum'|'type'|
+     *  'heading-section'|'paragraph'|'generic'|'fallback'` (dsgn-001 §2, dsgn-004 §3).
+     */
+    chunkType;
+    /** Karakter-/sor-pozíció a forráson belül (dsgn-001 §2). */
+    position;
+    /** MD heading-lánc VAGY kód-symbol-lánc (`['class:Foo','method:bar']`) — dsgn-004 §3. */
+    headingPath = [];
+    // --- provenance / csoportosítás ---
+    /** Ki/mi adta hozzá (dsgn-001 §6). */
+    addedBy;
+    /** Ingest-futtatás csoportosító ID (dsgn-004 §5). */
+    ingestRunId;
+    /** Külső import-forrás (pl. `'claude-mem'` — dsgn-009). */
+    importSource;
+    /** Eredeti rendszer rekord-azonosítója (dedup). */
+    importSourceId;
+    constructor(set) {
+        super(set);
+        if (set) {
+            fsm_dynamo_1.DyFM_Object.cleanAssign(this, set);
+        }
+    }
+}
+exports.FAM_Entry = FAM_Entry;