@futdevpro/fdp-agent-memory 0.1.0 → 1.1.12

package/build/src/_modules/ingest/_collections/fam-file-routing.util.js

@@ -9,77 +9,88 @@ const fam_table_type_enum_1 = require("../../../_enums/fam-table.type-enum");
  * felderített fájlt a kiterjesztése / fájlnév-mintája alapján `documents` / `codebase` / `skip`
  * cél-tárra route-ol. Statikus util (nincs DB-/service-függés).
  *
- * Routing-térkép (dsgn-004 §2):
- * - `documents` ← `.md` `.mdx` `.txt` `.rst`
- * - `codebase`  ← `.html` `.ts` `.tsx` `.js` `.jsx` `.py` `.css` `.scss` `.json` + config-fájlok
- *                 (`*.config.*`, `tsconfig*.json`, `package.json`, `.eslintrc*`, `.prettierrc*`,
- *                 `*.yml`/`*.yaml`/`*.toml`/`*.ini`, `Dockerfile`)
- * - `skip`      ← minden egyéb (bináris, kép, lock-fájl, stb.) — verdikt nélkül, `filesSkipped`-ben.
- *
- * **A `.html` markup KIZÁRÓLAG `codebase`** (NEM `documents`) — a `documents` route a tartalmi
- * dokumentációt célozza (`.md`/`.mdx`/`.txt`/`.rst`), nem a markup-ot (dsgn-004 §2). A
- * `chunkStrategyFor` a route + kiterjesztés alapján adja a chunker-stratégiát (SP-4.2 dispatch).
+ * **FAM-REV-064 — „semmi ne vesszen el" inverzió:** a korábbi szűk ALLOWLIST (csak ismert kiterjesztés
+ * → tár, MINDEN MÁS → skip) szöveges, info-hordozó fájlokat ejtett el (pl. `.mdc` Cursor-rules, `.sh`,
+ * `.ps1`, `.xml`, git-hookok, `LICENSE`). Az új logika DENYLIST-alapú: a **dokumentum-kiterjesztések** a
+ * `documents` táron; a **known-binary** (kép/font/archív/média/bináris/office) + a **generált zaj** (lock-
+ * fájlok, `.min.*`, source-map) `skip`; **MINDEN MÁS szöveges fájl** (ismert VAGY ismeretlen kiterjesztés,
+ * extension-nélküli `LICENSE`/`Dockerfile`/git-hook) → `codebase`. A bináris-tartalmú álcázott fájlokat a
+ * scanner null-byte tartalom-ellenőrzése szűri (`binary-content` skip), így nem kerül szemét a generic
+ * chunkerbe. Így minden valódi szöveg bekerül; a tényleges bináris + a generált zaj kimarad.
  */
 class FAM_FileRouting_Util {
-    /** Dokumentum-kiterjesztések → `documents` (dsgn-004 §2). */
-    static DOCUMENT_EXTENSIONS = ['.md', '.mdx', '.txt', '.rst'];
-    /** Kód-/markup-kiterjesztések → `codebase` (a `.html` markup IDE tartozik, dsgn-004 §2). */
-    static CODE_EXTENSIONS = [
-        '.html', '.ts', '.tsx', '.mts', '.js', '.jsx', '.py', '.css', '.scss', '.json',
-        '.yml', '.yaml', '.toml', '.ini',
-    ];
-    /** Markdown-kiterjesztések (a header-aware chunker célja, dsgn-004 §3.2). */
-    static MARKDOWN_EXTENSIONS = ['.md', '.mdx'];
-    /** TS-szemantikus chunker kiterjesztései (dsgn-004 §3.1). */
-    static TS_EXTENSIONS = ['.ts', '.tsx', '.mts', '.js', '.jsx'];
-    /** Extension-nélküli config-fájlnevek → `codebase` (dsgn-004 §2). */
-    static CONFIG_FILENAMES = ['dockerfile'];
+    /** Dokumentum-kiterjesztések → `documents` (a `.mdc` Cursor-rules + `.markdown` IDE, FAM-REV-064). */
+    static DOCUMENT_EXTENSIONS = ['.md', '.mdx', '.markdown', '.mdc', '.txt', '.text', '.rst', '.adoc'];
+    /** Markdown-kiterjesztések (a header-aware chunker célja; a `.mdc`/`.markdown` is, FAM-REV-064). */
+    static MARKDOWN_EXTENSIONS = ['.md', '.mdx', '.markdown', '.mdc'];
+    /** TS-szemantikus chunker kiterjesztései (dsgn-004 §3.1; `.cjs`/`.cts`/`.mjs` is JS/TS-variáns). */
+    static TS_EXTENSIONS = ['.ts', '.tsx', '.mts', '.cts', '.js', '.jsx', '.cjs', '.mjs'];
+    /**
+     * Known-binary kiterjesztések → `skip` (FAM-REV-064 denylist). Kép/font/archív/média/futtatható/
+     * lefordított/office/adatbázis + source-map (`.map`). Az office/PDF szöveg-kinyerés BACKLOG (dsgn BACKLOG),
+     * ezért egyelőre skip (nem néma — `filesSkipped` + `skipReason`). NEM tartalmazza a `.svg`-t? — DE: a
+     * `.svg` döntően generált path-grafika (alacsony szemantikai szöveg), ezért IDE soroljuk.
+     */
+    static BINARY_EXTENSIONS = new Set([
+        // képek
+        '.png', '.jpg', '.jpeg', '.gif', '.bmp', '.ico', '.webp', '.tiff', '.tif', '.svg', '.psd', '.ai',
+        // fontok
+        '.woff', '.woff2', '.ttf', '.eot', '.otf',
+        // archívok
+        '.zip', '.tgz', '.gz', '.tar', '.rar', '.7z', '.bz2', '.xz', '.jar', '.war', '.nupkg',
+        // média
+        '.mp3', '.mp4', '.wav', '.avi', '.mov', '.mkv', '.flac', '.ogg', '.webm', '.m4a', '.aac',
+        // futtatható / lefordított
+        '.exe', '.dll', '.so', '.dylib', '.bin', '.o', '.a', '.lib', '.node', '.wasm', '.class', '.pyc', '.pyo',
+        // office / PDF (szöveg-kinyerés BACKLOG)
+        '.pdf', '.doc', '.docx', '.xls', '.xlsx', '.ppt', '.pptx', '.odt', '.ods',
+        // adatbázis / egyéb bináris
+        '.db', '.sqlite', '.sqlite3', '.mdb', '.dat', '.map',
+    ]);
     /**
-     * Egy fájl route-verdiktje (dsgn-004 §2). A kiterjesztés-térkép, majd a config-fájlnév-minták
-     * (extension-nélküli `Dockerfile`, `*.config.*`, `tsconfig*.json`, `.eslintrc*`, `.prettierrc*`)
-     * → `codebase`; egyébként `skip`. A vizsgálat case-insensitive a kiterjesztésre/fájlnévre.
+     * Egy fájl route-verdiktje (FAM-REV-064 denylist-inverzió). Sorrend: (1) generált-zaj (lock/`.min.`/
+     * source-map) → skip; (2) dokumentum-kiterjesztés → `documents`; (3) known-binary → skip; (4) MINDEN MÁS
+     * (bármilyen szöveg, ismeretlen kiterjesztés, extension-nélküli) → `codebase`. Case-insensitive.
      */
     static route(relativePath) {
         const fileName = path.basename(relativePath).toLowerCase();
         const extension = path.extname(fileName);
+        if (FAM_FileRouting_Util.isGeneratedNoise(fileName)) {
+            return 'skip';
+        }
         if (FAM_FileRouting_Util.DOCUMENT_EXTENSIONS.includes(extension)) {
             return fam_table_type_enum_1.FAM_Table.documents;
         }
-        if (FAM_FileRouting_Util.CODE_EXTENSIONS.includes(extension)) {
-            return fam_table_type_enum_1.FAM_Table.codebase;
-        }
-        if (FAM_FileRouting_Util.isConfigFile(fileName)) {
-            return fam_table_type_enum_1.FAM_Table.codebase;
+        if (FAM_FileRouting_Util.BINARY_EXTENSIONS.has(extension)) {
+            return 'skip';
         }
-        return 'skip';
+        // Minden egyéb (ismert kód, ismeretlen-de-szöveges, extension-nélküli LICENSE/Dockerfile/git-hook) →
+        // codebase. A bináris-tartalmú álcázott fájlt a scanner null-byte tartalom-ellenőrzése szűri.
+        return fam_table_type_enum_1.FAM_Table.codebase;
     }
     /**
-     * Config-fájl-e a fájlnév (dsgn-004 §2): extension-nélküli ismert config (`Dockerfile`) VAGY
-     * a `*.config.*` / `tsconfig*.json` / `package.json` / `.eslintrc*` / `.prettierrc*` minta.
+     * Generált / zaj fájl-e (FAM-REV-064): a lock-fájlok (pnpm-lock.yaml / package-lock.json / yarn.lock /
+     * `*.lock`), a minifikált bundle-k (`.min.js`/`.min.css`) — ezek hatalmasak + generáltak, NEM info-
+     * hordozó forrás, ezért `skip` (NEM vesztünk valódi információt; a forrás `.ts`/`.scss` megvan).
      */
-    static isConfigFile(fileName) {
-        if (FAM_FileRouting_Util.CONFIG_FILENAMES.includes(fileName)) {
-            return true;
-        }
-        if (fileName === 'package.json' || fileName === 'package-lock.json') {
-            return true;
-        }
-        if (/^tsconfig.*\.json$/.test(fileName)) {
+    static isGeneratedNoise(fileName) {
+        if (fileName === 'pnpm-lock.yaml' || fileName === 'package-lock.json' || fileName === 'yarn.lock'
+            || fileName === 'bun.lockb' || fileName === 'composer.lock') {
             return true;
         }
-        if (/\.config\./.test(fileName)) {
+        if (fileName.endsWith('.lock')) {
             return true;
         }
-        if (/^\.eslintrc/.test(fileName) || /^\.prettierrc/.test(fileName)) {
+        if (/\.min\.(js|css|mjs)$/.test(fileName)) {
             return true;
         }
         return false;
     }
     /**
-     * A chunker-stratégia kulcsa egy fájlhoz (SP-4.2 dispatch, dsgn-004 §3). `ts` a TS-szemantikus
-     * (.ts/.tsx/.mts/.js/.jsx), `md` a markdown-header-aware (.md/.mdx), `generic` minden más
-     * `documents`/`codebase` fájlra (config/JSON/HTML-markup/.txt/.rst). A `route` előfeltétel:
-     * `skip` fájlra NEM hívandó.
+     * A chunker-stratégia kulcsa egy fájlhoz (SP-4.2 dispatch, dsgn-004 §3). `ts` a TS/JS-szemantikus,
+     * `md` a markdown-header-aware (`.md`/`.mdx`/`.markdown`/`.mdc`), `generic` minden más `documents`/
+     * `codebase` fájlra (config/JSON/HTML/`.txt`/`.sh`/`.ps1`/`.xml`/ismeretlen-szöveg). A `route`
+     * előfeltétel: `skip` fájlra NEM hívandó.
      */
     static chunkStrategyFor(relativePath) {
         const extension = path.extname(path.basename(relativePath).toLowerCase());

package/build/src/_modules/ingest/_collections/fam-project-identity.util.js

@@ -0,0 +1,134 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ProjectIdentity_Util = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+/**
+ * `FAM_ProjectIdentity_Util` — egy scan-gyökér **projekt-identitásának** felismerése (git + `package.json`).
+ * A scan ebből (a) egy kereshető `knowledge` „project-identity" entry-t készít (név/verzió/leírás/függőségek/
+ * git-repo), és (b) reference-aliasokat (a package-név + rövid alakok → a projekt scope-ja). A parse-rész PURE
+ * (önállóan tesztelhető), a `detect` az IO-wrapper (a `.git`/`package.json` olvasása — opt-in: hiányzó fájl no-op).
+ */
+class FAM_ProjectIdentity_Util {
+    /** A generált identity-entry `kind`-ja. */
+    static KIND = 'project-identity';
+    /** A `package.json`-ból kinyert mezők (PURE — érvénytelen JSON → üres). */
+    static parsePackageJson(content) {
+        try {
+            const parsed = JSON.parse(content);
+            const deps = [
+                ...Object.keys(parsed.dependencies ?? {}),
+                ...Object.keys(parsed.peerDependencies ?? {}),
+            ];
+            return {
+                packageName: typeof parsed.name === 'string' ? parsed.name : undefined,
+                version: typeof parsed.version === 'string' ? parsed.version : undefined,
+                description: typeof parsed.description === 'string' ? parsed.description : undefined,
+                dependencies: Array.from(new Set(deps)).sort(),
+            };
+        }
+        catch {
+            return { dependencies: [] };
+        }
+    }
+    /** A git `origin` remote URL-je a `.git/config` tartalmából (PURE; nincs origin → undefined). */
+    static parseGitRemote(gitConfigContent) {
+        const lines = gitConfigContent.split(/\r?\n/);
+        let inOrigin = false;
+        for (const rawLine of lines) {
+            const line = rawLine.trim();
+            if (line.startsWith('[remote ')) {
+                inOrigin = line.includes('"origin"');
+                continue;
+            }
+            if (inOrigin && line.startsWith('url')) {
+                const eq = line.indexOf('=');
+                if (eq >= 0) {
+                    return line.slice(eq + 1).trim();
+                }
+            }
+        }
+        return undefined;
+    }
+    /** Egy git-remote-URL → `org/repo` rövid alak (`.git` levágva; SSH/HTTPS egyaránt; PURE). Hiba → undefined. */
+    static shortRepo(remoteUrl) {
+        if (!remoteUrl) {
+            return undefined;
+        }
+        // git@host:org/repo.git  VAGY  https://host/org/repo.git
+        const afterHost = remoteUrl.includes(':') && !remoteUrl.startsWith('http')
+            ? remoteUrl.slice(remoteUrl.lastIndexOf(':') + 1)
+            : remoteUrl.replace(/^https?:\/\/[^/]+\//, '');
+        const cleaned = afterHost.replace(/\.git$/, '').replace(/^\/+/, '');
+        const segments = cleaned.split('/').filter(Boolean);
+        return segments.length >= 2 ? segments.slice(-2).join('/') : (segments[0] || undefined);
+    }
+    /** A projekt-identitás felismerése egy scan-gyökérből (IO: `package.json` + `.git/config`). Hiányzó → részleges. */
+    static detect(rootAbsolutePath) {
+        const identity = { isGit: false, dependencies: [] };
+        try {
+            const pkgPath = path.join(rootAbsolutePath, 'package.json');
+            if (fs.existsSync(pkgPath)) {
+                const parsed = FAM_ProjectIdentity_Util.parsePackageJson(fs.readFileSync(pkgPath, 'utf-8'));
+                identity.packageName = parsed.packageName;
+                identity.version = parsed.version;
+                identity.description = parsed.description;
+                identity.dependencies = parsed.dependencies;
+            }
+            const gitDir = path.join(rootAbsolutePath, '.git');
+            if (fs.existsSync(gitDir)) {
+                identity.isGit = true;
+                const configPath = path.join(gitDir, 'config');
+                if (fs.existsSync(configPath)) {
+                    identity.gitRemote = FAM_ProjectIdentity_Util.parseGitRemote(fs.readFileSync(configPath, 'utf-8'));
+                    identity.gitRepo = FAM_ProjectIdentity_Util.shortRepo(identity.gitRemote);
+                }
+            }
+        }
+        catch {
+            // best-effort: az identitás-olvasás hibája NEM buktatja a scant (a részleges identity visszaadva).
+        }
+        return identity;
+    }
+    /** Van-e bármi érdemi identitás (package.json VAGY git) — különben nincs értelme entry-t generálni. */
+    static hasIdentity(identity) {
+        return Boolean(identity.packageName || identity.isGit);
+    }
+    /** A kereshető `knowledge` „project-identity" entry szövege (PURE). */
+    static buildContent(identity, scopeLabel, root) {
+        const lines = [];
+        lines.push(`Projekt-identitás — ${scopeLabel}`);
+        lines.push(`Gyökér: ${root}`);
+        if (identity.packageName) {
+            lines.push(`Csomag: ${identity.packageName}${identity.version ? ` v${identity.version}` : ''}`);
+        }
+        lines.push(`Git-projekt: ${identity.isGit ? 'igen' : 'nem'}${identity.gitRepo ? ` (repo: ${identity.gitRepo})` : ''}`);
+        if (identity.description) {
+            lines.push(`Leírás: ${identity.description}`);
+        }
+        if (identity.dependencies.length) {
+            lines.push(`Függőségek (${identity.dependencies.length}): ${identity.dependencies.join(', ')}`);
+        }
+        return lines.join('\n');
+    }
+    /** A reference-aliasok (a package-név + rövid alakok + repo + dir-név → a projekt scope-ja). Dedup, üresek nélkül (PURE). */
+    static buildAliases(identity, dirName, scopeCanonical) {
+        const aliases = [dirName, scopeCanonical];
+        if (identity.packageName) {
+            aliases.push(identity.packageName);
+            const bare = identity.packageName.replace(/^@[^/]+\//, ''); // @futdevpro/fsm-dynamo → fsm-dynamo
+            aliases.push(bare);
+            const firstSegment = bare.split('-')[0]; // fsm-dynamo → fsm
+            if (firstSegment && firstSegment !== bare) {
+                aliases.push(firstSegment);
+            }
+        }
+        if (identity.gitRepo) {
+            aliases.push(identity.gitRepo);
+            aliases.push(identity.gitRepo.split('/').pop() ?? '');
+        }
+        return Array.from(new Set(aliases.map((alias) => alias.trim()).filter(Boolean)));
+    }
+}
+exports.FAM_ProjectIdentity_Util = FAM_ProjectIdentity_Util;

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

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ScanProgress_Util = void 0;
+/**
+ * `FAM_ScanProgress_Util` (descriptive user feedback) — a scan **pre-becslés** + **futás-közbeni progress** PURE
+ * (DB-/provider-mentes) magja. A nagy, workspace-szintű scanhez: a hívó ELŐRE lássa a becsült időt, és FUTÁS
+ * közben kövesse a haladást (X/N fájl, %, chunk, verdikt-bontás, eltelt + ETA). Statikus util — a control-service
+ * a delta-számokból + az óra-időből táplálja; a formázás/ETA-matek itt izoláltan tesztelhető.
+ */
+class FAM_ScanProgress_Util {
+    /**
+     * Pre-scan idő-becslés az embeddelendő chunk-számból + a per-chunk-ms-ből. `estimatedSeconds = chunks×ms/1000`.
+     * Durva (a tényleges sebesség gép-/modell-függő); a futó scan ETA-ja pontosítja.
+     */
+    static estimate(set) {
+        const estimatedSeconds = Math.round((set.chunksToEmbed * set.msPerChunk) / 1000);
+        return {
+            chunksToEmbed: set.chunksToEmbed,
+            msPerChunk: set.msPerChunk,
+            estimatedSeconds: estimatedSeconds,
+            note: `~${FAM_ScanProgress_Util.formatDuration(estimatedSeconds)} embeddelés (${set.chunksToEmbed} chunk × `
+                + `${set.msPerChunk}ms — DURVA becslés, gép-/modell-függő; a futó scan ETA-ja pontosítja)`,
+        };
+    }
+    /** Másodperc → ember-olvasható (`45s` / `3m 20s` / `1h 5m`). Negatív/0 → `0s`. */
+    static formatDuration(totalSeconds) {
+        const s = Math.max(0, Math.round(totalSeconds));
+        if (s < 60) {
+            return `${s}s`;
+        }
+        const minutes = Math.floor(s / 60);
+        const remSec = s % 60;
+        if (minutes < 60) {
+            return remSec ? `${minutes}m ${remSec}s` : `${minutes}m`;
+        }
+        const hours = Math.floor(minutes / 60);
+        const remMin = minutes % 60;
+        return remMin ? `${hours}h ${remMin}m` : `${hours}h`;
+    }
+    /**
+     * Egy futás-közbeni progress-sor: `processed/total` fájl + %, chunk-szám, verdikt-bontás, eltelt idő + ETA.
+     * Az ETA a MÉRT sebességből (`processed / elapsed`) → a hátralévő fájlok ideje (csak ha van haladás + maradék).
+     * `[famIngest]` prefix → az activity-monitor allowlistjén keresztül megjelenik a konzol-ablakban.
+     */
+    static progressLine(set) {
+        const pct = set.total ? Math.round((set.processed / set.total) * 100) : 100;
+        const rate = set.processed / Math.max(set.elapsedSeconds, 0.001);
+        const remaining = set.total - set.processed;
+        const eta = rate > 0 && remaining > 0
+            ? `, ETA ~${FAM_ScanProgress_Util.formatDuration(remaining / rate)}`
+            : '';
+        return `[famIngest] feldolgozás ${set.processed}/${set.total} fájl (${pct}%), ${set.chunkCount} chunk, `
+            + `${set.verdicts.new} új / ${set.verdicts.modified} mód / ${set.verdicts.equal} vált., `
+            + `eltelt ${FAM_ScanProgress_Util.formatDuration(set.elapsedSeconds)}${eta}`;
+    }
+}
+exports.FAM_ScanProgress_Util = FAM_ScanProgress_Util;

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

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ScanSummary_Util = void 0;
+/**
+ * `FAM_ScanSummary_Util` (file-rendszer összefoglaló) — a scan által GENERÁLT, kereshető „mi van a projektben"
+ * ö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).
+ */
+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) {
+        const byDir = new Map();
+        for (const rawPath of set.relativePaths) {
+            const normalized = rawPath.replace(/\\/g, '/');
+            const slashIndex = normalized.lastIndexOf('/');
+            const dir = slashIndex >= 0 ? normalized.slice(0, slashIndex) : '';
+            const name = slashIndex >= 0 ? normalized.slice(slashIndex + 1) : normalized;
+            if (!byDir.has(dir)) {
+                byDir.set(dir, []);
+            }
+            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:`);
+        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}`);
+        }
+        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;
+    }
+}
+exports.FAM_ScanSummary_Util = FAM_ScanSummary_Util;

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

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_ScanWeight_Util = void 0;
+const fam_glob_match_util_1 = require("./fam-glob-match.util");
+/**
+ * `FAM_ScanWeight_Util` (FAM-REV-055) — a scan-idejű **súly-kiemelés** pure magja. A hívó (agent) scankor
+ * megadhat `weights` szabályokat (glob → súly), hogy a FONTOSABB fájlok chunkjai NAGYOBB retrieval-súlyt
+ * kapjanak (a `finalScore = score × weight` → előrébb a rangsorban). **First-match-wins:** a `weights` sorrend
+ * SZÁMÍT (az első illeszkedő szabály nyer). Nincs match → `undefined` (→ a tár model-default súlya marad).
+ */
+class FAM_ScanWeight_Util {
+    /**
+     * Az adott (projekt-relatív) fájl súlya a `weights` szabályokból: az ELSŐ illeszkedő minta súlya, vagy
+     * `undefined` (nincs szabály / nincs match). Az illesztés a `FAM_GlobMatch_Util` (a scan ignore/include-pal
+     * azonos szemantika). A negatív / nem-véges súlyt kihagyja (defenzív — a 0/negatív weight retrieval-kizárást
+     * jelentene; ha szándékos, a `write`-on át explicit állítható).
+     */
+    static resolve(relativePath, weights) {
+        if (!weights || !weights.length) {
+            return undefined;
+        }
+        for (const rule of weights) {
+            if (typeof rule.weight !== 'number' || !Number.isFinite(rule.weight) || rule.weight <= 0) {
+                continue;
+            }
+            if (fam_glob_match_util_1.FAM_GlobMatch_Util.matches(relativePath, rule.pattern)) {
+                return rule.weight;
+            }
+        }
+        return undefined;
+    }
+    /** Teszt-/spec-fájl-e (`*.spec.*` / `*.test.*` a TS/JS-kiterjesztéseken). FAM-REV-058. */
+    static isTestFile(relativePath) {
+        return /\.(spec|test)\.(ts|tsx|mts|cts|js|jsx|mjs|cjs)$/i.test(relativePath);
+    }
+    /**
+     * A fájl EFFEKTÍV súlya a DEFAULT teszt-súllyal (FAM-REV-058): az explicit scan-`weights` match NYER; különben
+     * egy teszt-/spec-fájl a `testFileWeight`-et kapja (a próza-nehéz specek különben az implementáció fölé
+     * rangsorolnak); különben `undefined` (→ a tár model-default súlya). A `testFileWeight===1` (nincs csökkentés)
+     * vagy hiánya → nincs default-súly.
+     */
+    static resolveWithDefault(relativePath, weights, testFileWeight) {
+        const explicit = FAM_ScanWeight_Util.resolve(relativePath, weights);
+        if (explicit !== undefined) {
+            return explicit;
+        }
+        if (typeof testFileWeight === 'number' && testFileWeight !== 1 && FAM_ScanWeight_Util.isTestFile(relativePath)) {
+            return testFileWeight;
+        }
+        return undefined;
+    }
+}
+exports.FAM_ScanWeight_Util = FAM_ScanWeight_Util;

package/build/src/_modules/ingest/_collections/fam-secret-exclude.util.js

@@ -3,9 +3,17 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_SecretExclude_Util = void 0;
 /**
  * `FAM_SecretExclude_Util` (SP-4.1, dsgn-004 §6.3) — a scan-réteg **fájlnév-/útvonal-alapú**
- * secret-kizárása. A felsorolt minták (`.env*`, `*.key`, `*.pem`, `*.p12`, `id_rsa*`, `*secret*`,
- * `*credential*`, `*.crt`, `secrets/` mappa) **SOHA** nem ingestálódnak; a kizárás a file-típus-
- * routing **ELŐTT** fut, és a kizárt fájlok a `filesSkipped`-be számolódnak (audit, NEM néma).
+ * secret-kizárása. A felsorolt minták (`.env*`, `*.key`, `*.pem`, `*.p12`, `id_rsa*`, `*.crt`,
+ * `secrets/` mappa + a `secret`/`credential` névrész NEM-forrásfájlokon) **SOHA** nem ingestálódnak;
+ * a kizárás a file-típus-routing **ELŐTT** fut, és a kizárt fájlok a `filesSkipped`-be számolódnak
+ * (audit, NEM néma).
+ *
+ * **FALSE-POSITIVE FIX (2026-06-20 audit):** a korábbi `*secret*` / `*credential*` substring-minta
+ * **bármely** forrásfájlt is kizárt, aminek a neve tartalmazta ezeket (pl. maga a
+ * `fam-secret-exclude.util.ts`, vagy egy `secret-manager.service.ts`) → kód-RAG-lefedettség-rés. Ezért
+ * a `secret`/`credential` névrész-minta MOST CSAK **nem-forrás/doc-kiterjesztésekre** alkalmazódik
+ * (egy `.ts`/`.md` fájl, aminek a neve „secret", az KÓD a titokról, NEM titok-fájl). A valódi titok-
+ * fájlok (`.env`/`.key`/`.pem`/…) kiterjesztés-/névalapon továbbra is mindig kizártak.
  *
  * **HATÁR (dsgn-004 §6 megjegyzés + `MP-4-detailed` kockázat) — KIFEJEZETTEN BACKLOG:** ez CSAK
  * fájlnév-/útvonal-alapú kizárás. A **tartalmi** PII/secret-detektálás (a fájlon BELÜLI titkok
@@ -15,12 +23,10 @@ exports.FAM_SecretExclude_Util = void 0;
  */
 class FAM_SecretExclude_Util {
     /**
-     * A beépített secret-fájlnév-minták (dsgn-004 §6.3). Ezek a `scan.ignorePatterns` config
-     * biztonsági default-jával átfedők (dsgn-007 §4.5 `SCAN_IGNORE_PATTERNS_DEFAULT`), de a scan
-     * ettől FÜGGETLENÜL is alkalmazza őket (a config-override NEM kapcsolhatja ki a secret-védelmet).
-     * A vizsgálat a fájlnévre (regex) + az útvonal-szegmensekre (`secrets/`) megy.
+     * HARD secret-fájlnév-minták (dsgn-004 §6.3) — **MINDIG** kizárnak, kiterjesztéstől függetlenül:
+     * ezek a fájlok maguk a titkok (kulcs/cert/env). A config-override NEM kapcsolhatja ki őket.
      */
-    static SECRET_FILENAME_PATTERNS = [
+    static HARD_SECRET_PATTERNS = [
         /^\.env(\..*)?$/i, // .env, .env.local, .env.production, ...
         /\.key$/i, // *.key
         /\.pem$/i, // *.pem
@@ -29,14 +35,24 @@ class FAM_SecretExclude_Util {
         /\.pfx$/i, // *.pfx (cert)
         /^id_rsa.*$/i, // id_rsa, id_rsa.pub, ...
         /^id_ed25519.*$/i, // id_ed25519, id_ed25519.pub
-        /secret/i, // *secret* (bárhol a fájlnévben)
-        /credential/i, // *credential* (bárhol a fájlnévben)
     ];
+    /**
+     * SOFT névrész-minták (`secret`/`credential` bárhol a fájlnévben) — CSAK NEM-forrás/doc-fájlokra
+     * (pl. `secrets.json`, `my-credential.txt`). Egy `.ts`/`.md` fájl, aminek a neve „secret", az KÓD/
+     * DOC a titokról (legit forrás), NEM titok → ingestálódik (false-positive fix, lásd osztály-jsdoc).
+     */
+    static SOFT_SECRET_NAME_PATTERNS = [
+        /secret/i, // *secret* (csak nem-forrás kiterjesztésen)
+        /credential/i, // *credential* (csak nem-forrás kiterjesztésen)
+    ];
+    /** Ismert FORRÁS-/DOC-kiterjesztések — ezeken a SOFT névrész-minta NEM zár ki (legit kód/doc). */
+    static SOURCE_DOC_EXTENSION = /\.(ts|tsx|mts|cts|js|jsx|mjs|cjs|md|markdown)$/i;
     /** A secret-mappák (az útvonal BÁRMELY szegmense — pl. `secrets/`, `.ssh/`). */
     static SECRET_DIR_SEGMENTS = ['secrets', '.ssh', '.gnupg'];
     /**
-     * Secret-e a (projekt-relatív, `/`-normalizált) útvonal — fájlnév-minta VAGY secret-mappa-
-     * szegmens alapján (dsgn-004 §6.3). `true` → SOHA nem ingestálódik (`filesSkipped`, audit).
+     * Secret-e a (projekt-relatív, `/`-normalizált) útvonal — secret-mappa-szegmens VAGY HARD-minta
+     * VAGY (nem-forrásfájlon) SOFT névrész-minta alapján (dsgn-004 §6.3). `true` → SOHA nem ingestálódik
+     * (`filesSkipped`, audit).
      */
     static isSecret(relativePath) {
         const normalized = relativePath.replace(/\\/g, '/');
@@ -47,8 +63,15 @@ class FAM_SecretExclude_Util {
         if (dirSegments.some((segment) => FAM_SecretExclude_Util.SECRET_DIR_SEGMENTS.includes(segment))) {
             return true;
         }
-        // (2) Secret-fájlnév-minta.
-        return FAM_SecretExclude_Util.SECRET_FILENAME_PATTERNS.some((pattern) => pattern.test(fileName));
+        // (2) HARD secret-fájlnév-minta (mindig).
+        if (FAM_SecretExclude_Util.HARD_SECRET_PATTERNS.some((pattern) => pattern.test(fileName))) {
+            return true;
+        }
+        // (3) SOFT névrész-minta — CSAK ha NEM ismert forrás-/doc-kiterjesztés (a "secret"-nevű .ts legit kód).
+        if (FAM_SecretExclude_Util.SOURCE_DOC_EXTENSION.test(fileName)) {
+            return false;
+        }
+        return FAM_SecretExclude_Util.SOFT_SECRET_NAME_PATTERNS.some((pattern) => pattern.test(fileName));
     }
 }
 exports.FAM_SecretExclude_Util = FAM_SecretExclude_Util;

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

@@ -32,6 +32,19 @@ class FAM_SlidingChunker_Util {
             if (paragraphStart >= 0) {
                 charCursor = paragraphStart;
             }
+            // FAM-REV-065: egy paragrafus ÖNMAGÁBAN a maxSize felett (pl. sortörés-nélküli nagy JSON/blob) →
+            // flush + HARD-SPLIT (char-vágás maxSize-onként). KÜLÖNBEN egyetlen óriás-chunk lenne, ami az
+            // embedding-modell token-limitjét túllépi → `error` státusz → a tartalom NEM kereshető (info-veszteség).
+            if (paragraph.length > sizing.maxSize) {
+                if (currentText.trim().length) {
+                    FAM_SlidingChunker_Util.emit(chunks, currentText.trim(), currentCharStart, sizing.minSize);
+                    currentText = '';
+                }
+                FAM_SlidingChunker_Util.hardSplit(chunks, paragraph, charCursor, sizing);
+                charCursor = charCursor + paragraph.length;
+                currentCharStart = charCursor;
+                continue;
+            }
             if (currentText.length && currentText.length + paragraph.length + 2 > sizing.maxSize) {
                 FAM_SlidingChunker_Util.emit(chunks, currentText.trim(), currentCharStart, sizing.minSize);
                 if (currentText.length > sizing.overlap) {
@@ -60,6 +73,27 @@ class FAM_SlidingChunker_Util {
         }
         return chunks;
     }
+    /**
+     * Egy maxSize feletti, természetes törés-pont NÉLKÜLI szöveg HARD-SPLIT-je (FAM-REV-065): char-vágás
+     * `maxSize`-onként, `overlap`-pal lépve. A darabok a `minSize`-szűrés ALÓL MENTESEK (a tail-darab is kell
+     * — semmi ne vesszen el), és a `position` a forrás-offszetre mutat. Így a nagy JSON/blob is embeddelhető
+     * (modell-token-limit alatti darabok), nem ragad `error`-ba.
+     */
+    static hardSplit(chunks, text, charStart, sizing) {
+        const step = Math.max(1, sizing.maxSize - sizing.overlap);
+        for (let i = 0; i < text.length; i += step) {
+            const piece = text.slice(i, i + sizing.maxSize);
+            chunks.push({
+                content: piece,
+                position: { charStart: charStart + i, charEnd: charStart + i + piece.length },
+                chunkType: 'generic',
+                headingPath: [],
+            });
+            if (i + sizing.maxSize >= text.length) {
+                break;
+            }
+        }
+    }
     /** Egy chunk hozzáadása `chunkType='generic'`-kel (zaj-szűrés a `minSize`-ra). */
     static emit(chunks, content, charStart, minSize) {
         if (content.length < minSize) {