@futdevpro/fdp-agent-memory 1.1.30 → 1.1.113

package/build/src/_modules/ingest/_collections/fam-scan-summary.util.js

@@ -6,25 +6,21 @@ exports.FAM_ScanSummary_Util = void 0;
  * összefoglaló PURE építője. A scan után egy `knowledge`-entry készül a mappastruktúrából (mappák + fájlok
  * felsorolása), hogy az agent lekérdezhesse a projekt/mappa tartalmát (NEM kell végigscannelnie). Statikus util.
  *
- * **Méret-korlát:** a per-mappa fájllista a `MAX_FILES_PER_DIR`-nál levágódik (`+N további`), a teljes szöveg a
- * `MAX_CHARS`-nál — így az összefoglaló egyetlen, embeddelhető chunk marad nagy fáknál is (minden MAPPA így is felsorolt).
+ * **NINCS info-vesztés (user-FR 2026-06-22):** minden fájl felsorolva (nincs per-mappa cap), és ha a teljes szöveg
+ * nem fér egy embeddelhető chunkba, akkor TÖBB, nagyjából EGYENLŐ RÉSZRE bontjuk a mappa-határon (`buildParts`) —
+ * SOSE vágunk le / nyelünk el tartalmat (a régi `MAX_FILES_PER_DIR` / `MAX_CHARS` csonkolás MEGSZŰNT).
  */
 class FAM_ScanSummary_Util {
     /** A generált összefoglaló-entry `kind`-ja. */
     static KIND = 'fs-summary';
     /** A generált összefoglaló-entry `source.type`-ja (a reconciliation `scan`-t szűr → ezt nem érinti). */
     static SOURCE_TYPE = 'scan-summary';
-    /** Per-mappa felsorolt fájlok plafonja (felette `+N további`). */
-    static MAX_FILES_PER_DIR = 80;
-    /** A teljes összefoglaló-szöveg plafonja (egyetlen embeddelhető chunk). */
-    static MAX_CHARS = 40000;
-    /**
-     * A mappastruktúra-összefoglaló szövege: fejléc (scope / root / fájl-számok) + a mappánként csoportosított,
-     * rendezett fájllista. A relatív utak `/`-normalizáltak; a gyökér-szintű fájlok a `(gyökér)` alatt.
-     */
-    static build(set) {
+    /** EGY rész (chunk) méret-budgetje. A split EZT tartja be — de SOHA nem nyel le infót (több rész lesz). */
+    static MAX_CHARS_PER_PART = 40000;
+    /** Relatív utak → `Map<dir, files[]>` (normalizált `/`, a gyökér-szint kulcsa `''`). */
+    static groupByDir(relativePaths) {
         const byDir = new Map();
-        for (const rawPath of set.relativePaths) {
+        for (const rawPath of relativePaths) {
             const normalized = rawPath.replace(/\\/g, '/');
             const slashIndex = normalized.lastIndexOf('/');
             const dir = slashIndex >= 0 ? normalized.slice(0, slashIndex) : '';
@@ -34,27 +30,57 @@ class FAM_ScanSummary_Util {
             }
             byDir.get(dir)?.push(name);
         }
-        const lines = [];
-        lines.push(`File-rendszer összefoglaló — ${set.scopeLabel}`);
-        lines.push(`Gyökér: ${set.root}`);
-        lines.push(`${set.relativePaths.length} fájl ingestelve (${set.tables.join(', ') || '—'}), ${set.skippedCount} kihagyva.`);
-        lines.push('');
-        lines.push(`Mappák (${byDir.size}) + fájlok:`);
+        return byDir;
+    }
+    /**
+     * A fs-összefoglaló embeddelhető RÉSZEI (user-FR 2026-06-22 — SOHA nem nyelünk le infót). Ha minden elfér egy
+     * `MAX_CHARS_PER_PART`-os chunkban → 1 rész. Egyébként a mappa-entry-ket (név szerint rendezve = tree-lokális)
+     * NAGYJÁBÓL EGYENLŐ, budget-tartó részekre csomagoljuk a MAPPA-HATÁRON (sose vágunk ketté egy mappát). Minden
+     * rész ugyanazt a fejlécet kapja + `(rész i/M)`. Minden fájl szerepel (nincs per-mappa cap). 1+ elemű tömb.
+     */
+    static buildParts(set) {
+        const byDir = FAM_ScanSummary_Util.groupByDir(set.relativePaths);
+        const header = [
+            `File-rendszer összefoglaló — ${set.scopeLabel}`,
+            `Gyökér: ${set.root}`,
+            `${set.relativePaths.length} fájl ingestelve (${set.tables.join(', ') || '—'}), ${set.skippedCount} kihagyva.`,
+            '',
+            `Mappák (${byDir.size}) + fájlok:`,
+        ].join('\n');
+        const dirEntries = [];
         for (const dir of Array.from(byDir.keys()).sort()) {
             const files = (byDir.get(dir) ?? []).sort();
             const label = dir === '' ? '(gyökér)' : `${dir}/`;
-            const shown = files.length > FAM_ScanSummary_Util.MAX_FILES_PER_DIR
-                ? files.slice(0, FAM_ScanSummary_Util.MAX_FILES_PER_DIR)
-                : files;
-            const more = files.length > FAM_ScanSummary_Util.MAX_FILES_PER_DIR
-                ? ` (+${files.length - FAM_ScanSummary_Util.MAX_FILES_PER_DIR} további)`
-                : '';
-            lines.push(`  ${label} — ${files.length} fájl: ${shown.join(', ')}${more}`);
+            dirEntries.push(`  ${label} — ${files.length} fájl: ${files.join(', ')}`);
         }
-        const content = lines.join('\n');
-        return content.length > FAM_ScanSummary_Util.MAX_CHARS
-            ? `${content.slice(0, FAM_ScanSummary_Util.MAX_CHARS)}\n… (összefoglaló levágva a méret-plafonnál)`
-            : content;
+        const single = `${header}\n${dirEntries.join('\n')}`;
+        if (single.length <= FAM_ScanSummary_Util.MAX_CHARS_PER_PART) {
+            return [single];
+        }
+        // Split: budget = a part-plafon a fejléc + a `(rész i/M)` overhead levonásával. Greedy pack a mappa-határon.
+        const budget = Math.max(1000, FAM_ScanSummary_Util.MAX_CHARS_PER_PART - header.length - 24);
+        const groups = [];
+        let current = [];
+        let currentLen = 0;
+        for (const entry of dirEntries) {
+            const addLen = entry.length + 1;
+            if (current.length > 0 && currentLen + addLen > budget) {
+                groups.push(current);
+                current = [];
+                currentLen = 0;
+            }
+            // Egy túl-nagy mappa-entry (egyetlen óriás-mappa) saját, esetleg budget-feletti, DE TELJES részbe kerül.
+            current.push(entry);
+            currentLen += addLen;
+        }
+        if (current.length > 0) {
+            groups.push(current);
+        }
+        return groups.map((group, index) => `${header}  (rész ${index + 1}/${groups.length})\n${group.join('\n')}`);
+    }
+    /** A teljes összefoglaló EGY szövegként (a részek összefűzve) — debug/teszt. A persist a `buildParts`-ot használja. */
+    static build(set) {
+        return FAM_ScanSummary_Util.buildParts(set).join('\n\n');
     }
 }
 exports.FAM_ScanSummary_Util = FAM_ScanSummary_Util;

package/build/src/_modules/ingest/_collections/fam-split-chunker.util.js

@@ -0,0 +1,139 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_SplitChunker_Util = void 0;
+/**
+ * `FAM_SplitChunker_Util` (Rules-Management MP-3 / F-B) — **STRUKTURÁLIS** split-chunker: 1 strukturális elem = 1 chunk
+ * (= 1 entry), a méret-alapú chunking HELYETT. A „N szabály egy fájlban" minta vesztességmentes szétbontása, hogy
+ * minden szabály ÖNÁLLÓ, kereshető/injektálható entry legyen.
+ *
+ * - **`heading` mód:** minden heading-blokk (a heading-sor + a törzse a KÖVETKEZŐ headingig) = 1 chunk; a `headingPath`
+ *   az ŐS-láncot is tartja (kontextus). A legelső heading ELŐTTi preambulum külön chunk (semmi nem vész el).
+ * - **`list-item` mód:** minden TOP-szintű lista-elem (`- `/`* `/`+ `/`N. `) + a behúzott folytatása = 1 chunk; az első
+ *   elem előtti bevezető külön chunk.
+ *
+ * **PURE** (nincs config/fs/DB). A `chunkType = 'rule-split'`. Üres tartalom → üres lista.
+ */
+class FAM_SplitChunker_Util {
+    static HEADING_REGEX = /^(#{1,6})\s+(.+)$/;
+    static LIST_ITEM_REGEX = /^(\s*)([-*+]|\d+\.)\s+\S/;
+    /** Strukturális split a megadott mód szerint. */
+    static chunkStructural(text, mode) {
+        if (!text || !text.trim()) {
+            return [];
+        }
+        const blocks = mode === 'list-item'
+            ? FAM_SplitChunker_Util.splitByListItem(text)
+            : FAM_SplitChunker_Util.splitByHeading(text);
+        return blocks
+            .filter((block) => block.content.trim().length > 0)
+            .map((block) => ({
+            content: block.content.trim(),
+            position: {
+                charStart: block.charStart, charEnd: block.charEnd,
+                lineStart: block.lineStart, lineEnd: block.lineEnd,
+            },
+            chunkType: 'rule-split',
+            headingPath: block.headingPath,
+        }));
+    }
+    /** Heading-blokkonkénti bontás (a heading-stack adja az ős-láncot a `headingPath`-hoz). */
+    static splitByHeading(text) {
+        const lines = text.split(/\r?\n/);
+        const blocks = [];
+        const headingStack = [];
+        let buffer = [];
+        let blockCharStart = 0;
+        let blockLineStart = 1;
+        let charCursor = 0;
+        // A FOLYÓ blokk heading-láncának pillanatfelvétele (a blokk NYITÁSAKOR rögzítve).
+        let blockHeadingPath = [];
+        const flush = (lineEnd, charEnd) => {
+            if (buffer.join('\n').trim().length > 0) {
+                blocks.push({
+                    content: buffer.join('\n'), headingPath: blockHeadingPath,
+                    charStart: blockCharStart, charEnd: charEnd, lineStart: blockLineStart, lineEnd: lineEnd,
+                });
+            }
+        };
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const match = line.match(FAM_SplitChunker_Util.HEADING_REGEX);
+            if (match) {
+                // Lezárjuk a folyó blokkot (a preambulumot VAGY az előző heading-blokkot) a heading ELŐTT.
+                flush(i, charCursor);
+                // A stack frissítése az új heading szintjére.
+                const level = match[1].length;
+                while (headingStack.length && headingStack[headingStack.length - 1].level >= level) {
+                    headingStack.pop();
+                }
+                headingStack.push({ level: level, text: match[2].trim() });
+                // Új blokk: a heading-sorral KEZDŐDIK (önhordó content), a heading-lánc = a teljes stack.
+                buffer = [line];
+                blockHeadingPath = headingStack.map((heading) => '#'.repeat(heading.level) + ' ' + heading.text);
+                blockCharStart = charCursor;
+                blockLineStart = i + 1;
+            }
+            else {
+                buffer.push(line);
+            }
+            charCursor += line.length + 1;
+        }
+        flush(lines.length, charCursor);
+        return blocks;
+    }
+    /** Top-szintű lista-elemenkénti bontás (az első elem előtti bevezető külön blokk). */
+    static splitByListItem(text) {
+        const lines = text.split(/\r?\n/);
+        const blocks = [];
+        // A TOP-szint behúzása = az első lista-elem indentje (a mélyebb behúzás a folytatás).
+        const topIndent = FAM_SplitChunker_Util.detectTopIndent(lines);
+        let buffer = [];
+        let blockCharStart = 0;
+        let blockLineStart = 1;
+        let charCursor = 0;
+        const flush = (lineEnd, charEnd) => {
+            if (buffer.join('\n').trim().length > 0) {
+                blocks.push({
+                    content: buffer.join('\n'), headingPath: [],
+                    charStart: blockCharStart, charEnd: charEnd, lineStart: blockLineStart, lineEnd: lineEnd,
+                });
+            }
+        };
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            const isTopItem = FAM_SplitChunker_Util.isTopLevelItem(line, topIndent);
+            if (isTopItem && buffer.length) {
+                flush(i, charCursor);
+                buffer = [line];
+                blockCharStart = charCursor;
+                blockLineStart = i + 1;
+            }
+            else {
+                if (!buffer.length) {
+                    blockCharStart = charCursor;
+                    blockLineStart = i + 1;
+                }
+                buffer.push(line);
+            }
+            charCursor += line.length + 1;
+        }
+        flush(lines.length, charCursor);
+        return blocks;
+    }
+    /** Az első lista-elem behúzása (top-szint); ha nincs lista, 0. */
+    static detectTopIndent(lines) {
+        for (const line of lines) {
+            const match = line.match(FAM_SplitChunker_Util.LIST_ITEM_REGEX);
+            if (match) {
+                return match[1].length;
+            }
+        }
+        return 0;
+    }
+    /** Top-szintű lista-elem-e a sor (lista-elem ÉS a behúzása a top-indenttel egyezik). */
+    static isTopLevelItem(line, topIndent) {
+        const match = line.match(FAM_SplitChunker_Util.LIST_ITEM_REGEX);
+        return !!match && match[1].length === topIndent;
+    }
+}
+exports.FAM_SplitChunker_Util = FAM_SplitChunker_Util;

package/build/src/_modules/ingest/_models/interfaces/fam-scan-job.interface.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/build/src/_modules/ingest/_services/fam-chunker.control-service.js

@@ -6,6 +6,7 @@ const fam_file_routing_util_1 = require("../_collections/fam-file-routing.util")
 const fam_ts_chunker_util_1 = require("../_collections/fam-ts-chunker.util");
 const fam_md_chunker_util_1 = require("../_collections/fam-md-chunker.util");
 const fam_sliding_chunker_util_1 = require("../_collections/fam-sliding-chunker.util");
+const fam_split_chunker_util_1 = require("../_collections/fam-split-chunker.util");
 /**
  * `FAM_Chunker_ControlService` (SP-4.2, dsgn-004 §3) — a chunker-dispatch. A route + kiterjesztés
  * alapján stratégiát választ (TS-semantic | markdown | generic-sliding), a méret-konstansokat a
@@ -32,6 +33,15 @@ class FAM_Chunker_ControlService {
      * teljes batch-re konzisztens (a delta-kulcshoz, SP-4.3).
      */
     async chunkFile(set) {
+        // F-B (MP-3): explicit split-mód → strukturális bontás (a méret-stratégia + tiny-fallback megkerülésével; az
+        // author szándéka, hogy minden strukturális elem ÖNÁLLÓ entry legyen — még ha rövid is). Üres → tiny-fallback.
+        if (set.splitMode) {
+            const splitChunks = fam_split_chunker_util_1.FAM_SplitChunker_Util.chunkStructural(set.content, set.splitMode);
+            if (splitChunks.length) {
+                return this.assignIndices(splitChunks);
+            }
+            return set.content.trim().length ? [this.fallbackChunk(set.content)] : [];
+        }
         const strategy = fam_file_routing_util_1.FAM_FileRouting_Util.chunkStrategyFor(set.relativePath);
         const fallbackUnder = await this.resolveNumber('chunk.fallbackWholeFileUnder', set.table, set.scopePath, 50);
         // Tiny-file fallback (a `fallbackWholeFileUnder` alatt → 1 chunk, dsgn-004 §3.4).

package/build/src/_modules/ingest/_services/fam-delta-compare.util.js

@@ -32,7 +32,17 @@ class FAM_DeltaCompare_Util {
      * A `contentHash`-t a util itt számolja az ÚJ chunkokra (`FAM_ContentHash_Util.hash`,
      * normalizált) — az `existing.contentHash` a táron tárolt érték.
      */
-    static compare(newChunks, existing) {
+    static compare(newChunks, existing, accumulateOnly = false) {
+        // ACCUMULATE-ONLY (user-FR 2026-06-24, a `memory` tár) — a „felülírás azonos fájl-locationnél" szemantika a
+        // kódbázis/dokumentáció/rules-é, de a MEMÓRIÁRA NEM: ott minden szken TISZTÁN ADDITÍV. A dedup ekkor NEM a
+        // `(fájl, chunkIndex)` kulcson megy (az a kompaktáláskor téves `modified`/`deleted`-et adna → adatvesztés),
+        // hanem a CONTENT-HASH HALMAZON: egy chunk `equal` (skip), ha a tartalma MÁR LÉTEZIK a fájl történetében;
+        // különben `new` (insert). SOHA nincs `modified` (felülírás) és `deleted` (törlés) → a kompaktálás-előtti
+        // tartalom örökre megmarad, az ismételt szken pedig nem duplikál (a hash-egyezés kiszűri).
+        if (accumulateOnly) {
+            // egyetlen implementáció: a content-addressed additív összevetés (existingId + status backfillel, within-batch dedup).
+            return FAM_DeltaCompare_Util.compareAdditive(newChunks, existing);
+        }
         const existingByIndex = new Map();
         for (const entry of existing) {
             if (typeof entry.chunkIndex === 'number') {
@@ -73,5 +83,62 @@ class FAM_DeltaCompare_Util {
         }
         return items;
     }
+    /**
+     * ADDITÍV (content-addressed) delta — a `preserveHistory` szken igazi SUPERSET-szemantikája (user-FR 2026-06-24,
+     * memória-archívum). A chunk-identitás itt a **`contentHash`**, NEM a `(fájl, chunkIndex)` — így amikor egy fájl
+     * (pl. a kompaktált MEMORY.md) ÁTÍRÓDIK/RÖVIDÜL, a régi tartalom NEM vész el:
+     *
+     * - `equal` : a chunk `contentHash`-e MÁR létezik a táron (a fájlra) → skip (nincs re-embed; az `existingId` a
+     *             meglévő egyező chunk — a metaadat-backfillhez).
+     * - `new`   : a `contentHash` még nincs → insert új embeddinggel (a régi, eltérő-tartalmú chunkok MELLÉ).
+     * - **SOHA `deleted` és SOHA `modified`** — a régi (kompaktálás-előtti) tartalom megmarad a FAM-ban, akkor is, ha
+     *   a forrásból kikerült. Így a kompaktálás + újra-szken VESZTESÉGMENTES (a FAM a memória minden valaha-látott
+     *   állapotának uniója).
+     */
+    static compareAdditive(newChunks, existing) {
+        const existingByHash = new Map();
+        for (const entry of existing) {
+            if (typeof entry.contentHash === 'string' && entry.contentHash) {
+                // az ELSŐ előfordulást tartjuk (a metaadat-backfill cél-id-ja); a duplikált hash-ek nem számítanak
+                if (!existingByHash.has(entry.contentHash)) {
+                    existingByHash.set(entry.contentHash, entry);
+                }
+            }
+        }
+        const items = [];
+        const emittedHashes = new Set();
+        for (const chunk of newChunks) {
+            const contentHash = fam_content_hash_util_1.FAM_ContentHash_Util.hash(chunk.content);
+            // a batch-en BELÜLI duplikátum-tartalmat is csak egyszer (ne ágyazzunk be kétszer ugyanazt)
+            if (emittedHashes.has(contentHash)) {
+                continue;
+            }
+            emittedHashes.add(contentHash);
+            const existingEntry = existingByHash.get(contentHash);
+            if (existingEntry) {
+                items.push({
+                    verdict: 'equal', chunk: chunk, existingId: existingEntry._id, contentHash: contentHash,
+                    existingEmbeddingStatus: existingEntry.embeddingStatus,
+                });
+            }
+            else {
+                items.push({ verdict: 'new', chunk: chunk, contentHash: contentHash });
+            }
+        }
+        // (2) SUPERSESSION (dsgn-013 §6, MAM F4) — a táron maradt, az ÚJ batch-ben NEM szereplő tartalmú chunkok NEM
+        // törlődnek (additív invariáns), de LEVÁLTOTTÁ (`superseded`) jelölődnek: ezek a fájl RÉGI, már átírt/kivett
+        // tartalma (pl. a kompaktált MEMORY.md korábbi bejegyzései). Megőrizve + cold-kereshetők, de a ranking
+        // penalizálja őket (a friss verzió fölébük kerül). CSAK ha a fájlnak VAN új tartalma (`newChunks` nem üres) —
+        // különben (üres batch) nem leváltunk, csak nincs mit hozzáadni.
+        if (newChunks.length) {
+            for (const entry of existing) {
+                if (typeof entry.contentHash === 'string' && entry.contentHash
+                    && !emittedHashes.has(entry.contentHash) && !entry.superseded) {
+                    items.push({ verdict: 'superseded', chunk: null, existingId: entry._id, contentHash: entry.contentHash });
+                }
+            }
+        }
+        return items;
+    }
 }
 exports.FAM_DeltaCompare_Util = FAM_DeltaCompare_Util;

package/build/src/_modules/ingest/_services/fam-ingest-run.data-service.js

@@ -48,7 +48,7 @@ class FAM_IngestRun_DataService extends nts_dynamo_1.DyNTS_DataService {
             filesProcessed: 0,
             filesSkipped: 0,
             chunkCount: 0,
-            verdicts: { new: 0, modified: 0, equal: 0, deleted: 0 },
+            verdicts: { new: 0, modified: 0, equal: 0, deleted: 0, superseded: 0 },
             status: 'ok',
             errors: [],
         });