@futdevpro/fdp-agent-memory 0.1.0 → 1.1.12

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

@@ -5,9 +5,11 @@ exports.FAM_TsChunker_Util = void 0;
  * `FAM_TsChunker_Util` (SP-4.2, dsgn-004 §3.1, **BFR-AM-005 workaround**) — TypeScript-szemantikus
  * chunker `.ts/.tsx/.mts/.js/.jsx`-re. A CCAP `PS_TypeScriptChunker_Util` regex/brace-depth
  * megközelítésének projekt-lokális portja: import-csoport → top-level deklarációk (class/interface/
- * enum/type/function/const-export) → osztály-blokk (a metódus-bontás brace-depth-fel a nagy-blokk
- * ágon történik) → JSDoc + `@Decorator` a következő kód-chunkkal együtt → nagy blokk soronkénti
- * sliding-window-ra bomlik. A méret-konstansok a config-ból (`chunk.ts.*`), default `1500/100/50`.
+ * enum/type/function/const-export) → JSDoc + `@Decorator` a következő kód-chunkkal együtt. A max-size
+ * FELETTI blokk darabolása: **class → metódus-tudatos** (a class-body member-határai mentén; minden adekvát
+ * metódus a saját chunkja `['class:Foo','method:bar']` symbol-lánccal + `chunkType:'method'`, a class-fej +
+ * mezők egy `'class'` chunk), **egyéb nagy blokk** (hosszú függvény/interface/enum) → soronkénti
+ * sliding-window (örökölt chunkType + symbol-lánc). A méret-konstansok a config-ból (`chunk.ts.*`), default `1500/100/50`.
  *
  * **BFR-AM-005 (dsgn-004 §3.1 megjegyzés):** a regex/brace-depth téved string-literálban lévő `{`/`}`
  * vagy template-literál esetén — a `countBraces` konzervatívan kihagyja a string-/line-comment-
@@ -27,6 +29,8 @@ class FAM_TsChunker_Util {
     static TYPE_ALIAS_START = /^(?:export\s+)?type\s+(\w+)\s*=/;
     static STANDALONE_FUNCTION = /^(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s+(\w+)/;
     static CONST_EXPORT = /^(?:export\s+)?const\s+(\w+)/;
+    /** Class-member-signature → metódus-név (modifierek után `név(`); getter/setter/constructor is). */
+    static METHOD_SIG = /^(?:public|private|protected|static|async|readonly|abstract|override|get|set|\s)*\*?\s*([\w$]+)\s*(?:<[^>]*>)?\s*\(/;
     static DECORATOR_LINE = /^\s*@\w+/;
     static JSDOC_OPEN = /^\s*\/\*\*/;
     static JSDOC_CLOSE = /\*\//;
@@ -271,40 +275,222 @@ class FAM_TsChunker_Util {
         }
         return depth;
     }
-    /** Nagy blokk soronkénti sliding-window-ja (örökölt chunkType + symbol-`headingPath`). */
+    /**
+     * Nagy (max-size feletti) blokk darabolása. `class` (entityName-mel) → **metódus-tudatos** member-bontás
+     * (`splitClassByMembers`); egyéb nagy blokk (hosszú függvény/interface/enum) VAGY sikertelen class-parse →
+     * soronkénti sliding-window (`slidingWindowLines`).
+     */
     static splitLargeBlock(block, sizing, headingPath) {
+        if (block.blockType === 'class' && block.entityName) {
+            const classChunks = FAM_TsChunker_Util.splitClassByMembers(block, sizing, headingPath);
+            if (classChunks.length) {
+                return classChunks;
+            }
+        }
+        return FAM_TsChunker_Util.slidingWindowLines({
+            lines: block.lines, charStart: block.charStart, lineStart: block.lineStart,
+            sizing: sizing, headingPath: headingPath, chunkType: block.blockType,
+        });
+    }
+    /**
+     * Soronkénti sliding-window egy sor-tömbre (a nem-class nagy blokkok + a túl nagy egyetlen metódus
+     * fallbackja). Örökli a kapott `chunkType`-ot + `headingPath`-ot; a sub-chunkok a maxSize körül törnek,
+     * `overlap/80` sornyi átfedéssel lépnek.
+     *
+     * **FAM-REV-061:** minden ablak a SAJÁT abszolút `charStart`-ját kapja (a blokk-kezdet + az ablak első
+     * soráig tartó char-offset) — korábban MINDEN ablak `set.charStart`-ot kapott (a blokk kezdete), így a nagy
+     * blokk összes sub-chunkja azonos charStart-ra ütközött (a location-info „hányadik char/sor" félrevezetett).
+     */
+    static slidingWindowLines(set) {
         const chunks = [];
-        const lines = block.lines;
-        const overlapLines = Math.max(1, Math.floor(sizing.overlap / 80));
+        const lines = set.lines;
+        const overlapLines = Math.max(1, Math.floor(set.sizing.overlap / 80));
+        // Sor-kezdő char-offsetek a blokkon belül (a per-ablak abszolút charStart-hoz; +1 a `\n`-ért).
+        const lineCharOffset = [];
+        let acc = 0;
+        for (let i = 0; i < lines.length; i++) {
+            lineCharOffset[i] = acc;
+            acc += lines[i].length + 1;
+        }
         let startIdx = 0;
         while (startIdx < lines.length) {
             let currentText = '';
             let endIdx = startIdx;
             while (endIdx < lines.length) {
                 const candidate = currentText + (currentText ? '\n' : '') + lines[endIdx];
-                if (candidate.length > sizing.maxSize && currentText.length) {
+                if (candidate.length > set.sizing.maxSize && currentText.length) {
                     break;
                 }
                 currentText = candidate;
                 endIdx++;
             }
-            if (currentText.trim().length >= sizing.minSize) {
+            if (currentText.trim().length >= set.sizing.minSize) {
+                const windowCharStart = set.charStart + (lineCharOffset[startIdx] ?? 0);
                 chunks.push({
                     content: currentText,
                     position: {
-                        charStart: block.charStart,
-                        charEnd: block.charStart + currentText.length,
-                        lineStart: block.lineStart + startIdx,
-                        lineEnd: block.lineStart + endIdx - 1,
+                        charStart: windowCharStart,
+                        charEnd: windowCharStart + currentText.length,
+                        lineStart: set.lineStart + startIdx,
+                        lineEnd: set.lineStart + endIdx - 1,
                     },
-                    chunkType: block.blockType,
-                    headingPath: headingPath,
+                    chunkType: set.chunkType,
+                    headingPath: set.headingPath,
                 });
             }
             startIdx = Math.max(startIdx + 1, endIdx - overlapLines);
         }
         return chunks;
     }
+    /**
+     * Metódus-tudatos class-darabolás (FAM-REV-049): a class-body MEMBER-határait (brace-depth) követve a
+     * class-fejet + a metódusokat külön chunkokra bontja — minden adekvát (>= minSize) metódus a saját
+     * chunkja a beágyazott symbol-lánccal (`['class:Foo','method:bar']`, `chunkType:'method'`). A
+     * `parseClassUnits` 1-nél több unitot ad (class-fej + 1+ member) → `packClassUnits`; különben üres
+     * (a hívó soros slidingjára esik).
+     */
+    static splitClassByMembers(block, sizing, classHeadingPath) {
+        const units = FAM_TsChunker_Util.parseClassUnits(block);
+        if (units.length <= 1) {
+            return [];
+        }
+        return FAM_TsChunker_Util.packClassUnits(units, block, sizing, classHeadingPath);
+    }
+    /**
+     * A class-blokk member-egységekre bontása (FAM-REV-049): az első unit a class-FEJ (JSDoc + signature a
+     * body-nyitásig), majd a class-body memberei a brace-depth member-határai mentén (egy member zár, ha a
+     * body-szintre [depth 1] tér vissza, VAGY egy `;`-re végződő egy-soros field). Brace-depth (NEM AST).
+     */
+    static parseClassUnits(block) {
+        const lines = block.lines;
+        // (1) class-body nyitás: az első sor, ahol a kumulált brace-depth >= 1.
+        let depth = 0;
+        let openIdx = -1;
+        for (let i = 0; i < lines.length; i++) {
+            depth += FAM_TsChunker_Util.countBraces(lines[i]);
+            if (depth >= 1) {
+                openIdx = i;
+                break;
+            }
+        }
+        if (openIdx < 0) {
+            return [];
+        }
+        const units = [];
+        units.push({ lines: lines.slice(0, openIdx + 1), lineOffset: 0, isMethod: false });
+        // (2) a body memberei (depth 1-ről indulva).
+        let current = [];
+        let currentStart = openIdx + 1;
+        let bodyDepth = 1;
+        for (let i = openIdx + 1; i < lines.length; i++) {
+            const line = lines[i];
+            const before = bodyDepth;
+            bodyDepth += FAM_TsChunker_Util.countBraces(line);
+            if (bodyDepth <= 0) {
+                // class-záró `}` → a maradékot flush-öljük (a záró brace-sort nem külön chunkoljuk).
+                if (current.length) {
+                    units.push(FAM_TsChunker_Util.makeMemberUnit(current, currentStart));
+                }
+                break;
+            }
+            if (!current.length) {
+                currentStart = i;
+            }
+            current.push(line);
+            const closedBackToBody = before > 1 && bodyDepth === 1; // braced member (metódus) lezárult
+            const oneLineField = before === 1 && bodyDepth === 1 && line.trim().endsWith(';');
+            if (closedBackToBody || oneLineField) {
+                units.push(FAM_TsChunker_Util.makeMemberUnit(current, currentStart));
+                current = [];
+            }
+        }
+        return units;
+    }
+    /** Egy member-sortömb → `FAM_ClassUnit` (a signature-sorból kinyert metódus-névvel). */
+    static makeMemberUnit(lines, lineOffset) {
+        const sigLine = lines.find((line) => {
+            const trimmed = line.trim();
+            return trimmed.length > 0
+                && !trimmed.startsWith('/*') && !trimmed.startsWith('*') && !trimmed.startsWith('//')
+                && !trimmed.startsWith('@');
+        }) ?? '';
+        const match = sigLine.trim().match(FAM_TsChunker_Util.METHOD_SIG);
+        const isMethod = !!match && sigLine.includes('(');
+        return { lines: lines, lineOffset: lineOffset, name: match ? match[1] : undefined, isMethod: isMethod };
+    }
+    /**
+     * A member-egységek chunkokra csomagolása (FAM-REV-049): minSize-ig akkumulál (semmi ne essen ki a
+     * zaj-szűrőn), maxSize előtt flush-öl; az adekvát egy-metódusú chunk `method:`-symbol-láncot + `'method'`
+     * típust kap, a többi (class-fej / field-csoport) a `'class'` típust + a class-symbol-láncot. A maxSize
+     * feletti egyetlen member soros sliding-window-ra bomlik (örökölt symbol-lánc).
+     */
+    static packClassUnits(units, block, sizing, classHeadingPath) {
+        // Sor-kezdő char-offsetek a class-blokkon belül (a pontos charStart-hoz).
+        const lineCharOffset = [];
+        let acc = 0;
+        for (let i = 0; i < block.lines.length; i++) {
+            lineCharOffset[i] = acc;
+            acc += block.lines[i].length + 1;
+        }
+        const chunks = [];
+        let group = [];
+        const groupText = () => group.map((unit) => unit.lines.join('\n')).join('\n');
+        const flush = () => {
+            if (!group.length) {
+                return;
+            }
+            const text = groupText();
+            if (text.trim().length) {
+                const first = group[0];
+                const last = group[group.length - 1];
+                const lastLineOffset = last.lineOffset + last.lines.length - 1;
+                const single = group.length === 1 && first.isMethod && !!first.name;
+                const baseChar = block.charStart + (lineCharOffset[first.lineOffset] ?? 0);
+                chunks.push({
+                    content: text,
+                    position: {
+                        charStart: baseChar,
+                        charEnd: baseChar + text.length,
+                        lineStart: block.lineStart + first.lineOffset,
+                        lineEnd: block.lineStart + lastLineOffset,
+                    },
+                    chunkType: single ? 'method' : 'class',
+                    headingPath: single ? [...classHeadingPath, `method:${first.name}`] : classHeadingPath,
+                });
+            }
+            group = [];
+        };
+        for (const unit of units) {
+            const unitText = unit.lines.join('\n');
+            // Túl nagy egyetlen member → flush + soros sliding (örökölt method/class symbol-lánc).
+            if (unitText.length > sizing.maxSize) {
+                flush();
+                const headPath = unit.isMethod && unit.name
+                    ? [...classHeadingPath, `method:${unit.name}`]
+                    : classHeadingPath;
+                chunks.push(...FAM_TsChunker_Util.slidingWindowLines({
+                    lines: unit.lines,
+                    charStart: block.charStart + (lineCharOffset[unit.lineOffset] ?? 0),
+                    lineStart: block.lineStart + unit.lineOffset,
+                    sizing: sizing,
+                    headingPath: headPath,
+                    chunkType: unit.isMethod ? 'method' : 'class',
+                }));
+                continue;
+            }
+            // maxSize-túllépés a csoporttal → előbb flush.
+            if (group.length && (groupText().length + 1 + unitText.length) > sizing.maxSize) {
+                flush();
+            }
+            group.push(unit);
+            // Elérte a minSize-t → flush (az adekvát metódus így a SAJÁT chunkja marad).
+            if (groupText().trim().length >= sizing.minSize) {
+                flush();
+            }
+        }
+        flush();
+        return chunks;
+    }
     /** A symbol-`headingPath` egy blokkhoz (`['class:Foo']`); generic / névtelen → üres tömb. */
     static buildHeadingPath(block) {
         if (block.entityName && block.blockType !== 'generic' && block.blockType !== 'imports') {

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

@@ -51,7 +51,10 @@ class FAM_DeltaCompare_Util {
             }
             matchedIndices.add(chunk.chunkIndex);
             if (existingEntry.contentHash === contentHash) {
-                items.push({ verdict: 'equal', chunk: chunk, existingId: existingEntry._id, contentHash: contentHash });
+                items.push({
+                    verdict: 'equal', chunk: chunk, existingId: existingEntry._id, contentHash: contentHash,
+                    existingEmbeddingStatus: existingEntry.embeddingStatus, // FAM-REV-066: a re-embed-if-not-completed-hez
+                });
             }
             else {
                 items.push({ verdict: 'modified', chunk: chunk, existingId: existingEntry._id, contentHash: contentHash });

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

@@ -31,13 +31,16 @@ class FAM_IngestRun_DataService extends nts_dynamo_1.DyNTS_DataService {
         return new nts_dynamo_1.DyNTS_ArchiveDataService(new fam_ingest_run_data_model_1.FAM_IngestRun_DataModel(), this.dataParams, this.issuer);
     }
     /**
-     * A run megnyitása a scan ELEJÉN (dsgn-004 §5). A `_id` = a hívó által generált runId (UUID v4),
-     * hogy a chunkok az `ingestRunId`-vel HIVATKOZHASSANAK rá MÉG a run-zárás előtt. Friss `saveData`
-     * (új rekord — nincs Mixed-mutáció). A számlálók/verdiktek a `close`-ban frissülnek.
+     * A run megnyitása a scan ELEJÉN (dsgn-004 §5). A `_id`-t a Dynamo `saveData` GENERÁLJA (Mongo
+     * ObjectId, stringként) — a `FAM_Scope` mintáját követve (`findOrCreateScope`). **NEM** állítunk
+     * client-generált UUID `_id`-t: a Dynamo db-rétege a get-by-id-t `findById`-dal végzi, ami a `_id`-t
+     * ObjectId-ra cast-olja → egy UUID-string cast-ja elhasal (`DyNTS-DBS-GI0`). A hívó a VISSZAADOTT
+     * rekord `_id`-jét használja runId-ként (a chunkok ezzel az `ingestRunId`-vel hivatkoznak rá MÉG a
+     * run-zárás előtt). Friss `saveData` (új rekord — nincs Mixed-mutáció); a számlálók/verdiktek a
+     * `close`-ban frissülnek.
      */
     async open(set) {
         const record = new fam_ingest_run_data_model_1.FAM_IngestRun_DataModel({
-            _id: set.runId,
             trigger: set.trigger,
             table: set.table,
             scopePath: set.scopePath,