@futdevpro/fdp-agent-memory 0.1.0 → 1.1.14

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-git-repo.util.js

@@ -0,0 +1,193 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_GitRepo_Util = void 0;
+const tslib_1 = require("tslib");
+const fs = tslib_1.__importStar(require("fs"));
+const path = tslib_1.__importStar(require("path"));
+/**
+ * `FAM_GitRepo_Util` (user-FR 2026-06-21) — egy scannelt fájlhoz felderíti a **git-repo provenance-t**:
+ * a repo-gyökeret (`.git` felfelé keresve), a **GitHub/remote URL-t** (`.git/config` `remote.origin.url`,
+ * normalizálva), a **branch-et** (`.git/HEAD`) és a **repo-gyökérhez relatív utat**. **Függőség-mentes**
+ * (NEM `git`-parancs — közvetlenül a `.git/` fájlokból olvas; gyors + offline). A scan **repoRoot-onként cache-eli**
+ * (egy mappa-scan ~1 repo → egyszer olvas), így a per-fájl költség elhanyagolható.
+ *
+ * Miért így (a user „relative path + GitHub repo" döntése): a repo-URL + a **REPO-relatív** út KANONIKUS,
+ * gép-független, kattintható citáció (`<repoUrl>/blob/<branch>/<repoRelativePath>`) — szemben a gép-specifikus
+ * abszolút úttal vagy a törékeny „projektnévből kiszámolt" relatív úttal.
+ */
+class FAM_GitRepo_Util {
+    /** Meddig megyünk felfelé `.git`-et keresve (biztonsági korlát a végtelen ciklus ellen). */
+    static MAX_WALK_UP = 40;
+    /** Belső repoRoot→info cache (a scan-során a `.git` nem változik; egy repo → egyszer olvas). */
+    static _cache = new Map();
+    /**
+     * Egy scannelt fájl **scan-source git-mezői** (a `FAM_Source`-ba spread-elve): `repoUrl` / `repoName` /
+     * `repoRelativePath` (a repo-gyökérhez) / `repoBranch`. Cache-elt (belső statikus Map) + fail-safe (üres
+     * objektum, ha a fájl NINCS git-repóban / hiba) — a scan SOHA nem bukik el a git-felderítésen.
+     */
+    static sourceFieldsFor(absFilePath) {
+        try {
+            const info = FAM_GitRepo_Util.resolve(absFilePath, FAM_GitRepo_Util._cache);
+            if (!info) {
+                return {};
+            }
+            return {
+                repoUrl: info.repoUrl,
+                repoName: info.repoName,
+                repoRelativePath: FAM_GitRepo_Util.relativePath(absFilePath, info.repoRoot),
+                repoBranch: info.repoBranch,
+            };
+        }
+        catch {
+            return {};
+        }
+    }
+    /**
+     * A teljes repo-info felderítése egy fájl abszolút útjából, **cache-elve a repoRoot-on** (a hívó adja a
+     * Map-et; egy scan végig egyet használ). `null`, ha a fájl NINCS git-repóban. A relatív utat a hívó a
+     * `relativePath`-szal számolja (a repoRoot ismeretében).
+     */
+    static resolve(absFilePath, cache) {
+        const repoRoot = FAM_GitRepo_Util.findRepoRoot(absFilePath);
+        if (!repoRoot) {
+            return null;
+        }
+        const cached = cache.get(repoRoot);
+        if (cached !== undefined) {
+            return cached;
+        }
+        const remote = FAM_GitRepo_Util.readRemoteUrl(repoRoot);
+        const info = {
+            repoRoot: repoRoot,
+            repoUrl: remote?.url,
+            repoName: remote?.name,
+            repoBranch: FAM_GitRepo_Util.readBranch(repoRoot),
+        };
+        cache.set(repoRoot, info);
+        return info;
+    }
+    /** A repo-gyökér keresése felfelé (`.git` mappa VAGY fájl — a submodule `.git` fájl). `null`, ha nincs. */
+    static findRepoRoot(absStartPath) {
+        let dir = absStartPath;
+        try {
+            // Ha a start egy fájl, a könyvtárából indulunk; ha mappa, magából.
+            if (fs.existsSync(absStartPath) && fs.statSync(absStartPath).isFile()) {
+                dir = path.dirname(absStartPath);
+            }
+        }
+        catch {
+            dir = path.dirname(absStartPath);
+        }
+        for (let i = 0; i < FAM_GitRepo_Util.MAX_WALK_UP; i++) {
+            if (fs.existsSync(path.join(dir, '.git'))) {
+                return dir;
+            }
+            const parent = path.dirname(dir);
+            if (parent === dir) {
+                return null; // elértük a filesystem-gyökeret
+            }
+            dir = parent;
+        }
+        return null;
+    }
+    /**
+     * A `remote.origin.url` kiolvasása a `.git/config`-ból + normalizálva (`https://github.com/owner/repo`).
+     * `undefined`, ha nincs origin / nem olvasható. (A submodule `.git` FÁJL `gitdir:`-re mutat — ezt is követjük.)
+     */
+    static readRemoteUrl(repoRoot) {
+        try {
+            const gitPath = path.join(repoRoot, '.git');
+            const configPath = fs.statSync(gitPath).isDirectory()
+                ? path.join(gitPath, 'config')
+                : path.join(FAM_GitRepo_Util.resolveGitdir(repoRoot, gitPath), 'config');
+            if (!fs.existsSync(configPath)) {
+                return undefined;
+            }
+            const raw = fs.readFileSync(configPath, 'utf-8');
+            const rawUrl = FAM_GitRepo_Util.extractOriginUrl(raw);
+            return rawUrl ? FAM_GitRepo_Util.normalizeRepoUrl(rawUrl) : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** A `.git/HEAD`-ből az aktuális branch (`ref: refs/heads/<branch>`); detached SHA / hiba → `undefined`. */
+    static readBranch(repoRoot) {
+        try {
+            const gitPath = path.join(repoRoot, '.git');
+            const headPath = fs.statSync(gitPath).isDirectory()
+                ? path.join(gitPath, 'HEAD')
+                : path.join(FAM_GitRepo_Util.resolveGitdir(repoRoot, gitPath), 'HEAD');
+            const head = fs.readFileSync(headPath, 'utf-8').trim();
+            const match = head.match(/^ref:\s*refs\/heads\/(.+)$/);
+            return match ? match[1].trim() : undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** A fájl REPO-gyökérhez relatív útja (POSIX-szeparátorral, a kattintható citációhoz). */
+    static relativePath(absFilePath, repoRoot) {
+        return path.relative(repoRoot, absFilePath).replace(/\\/g, '/');
+    }
+    /**
+     * A nyers remote-URL normalizálása kattintható HTTPS-formára + `owner/repo` névre. Lefedi:
+     * `git@host:owner/repo.git`, `https://host/owner/repo.git`, `ssh://git@host/owner/repo.git`. A `.git`-suffix
+     * + a beágyazott credential levágva. Nem-github host esetén a host marad (gitlab/bitbucket is kattintható).
+     */
+    static normalizeRepoUrl(rawUrl) {
+        let url = rawUrl.trim();
+        // scp-szerű: git@host:owner/repo(.git) → https://host/owner/repo
+        const scp = url.match(/^[\w.-]+@([\w.-]+):(.+)$/);
+        if (scp) {
+            url = `https://${scp[1]}/${scp[2]}`;
+        }
+        url = url
+            .replace(/^ssh:\/\/(?:[\w.-]+@)?/, 'https://')
+            .replace(/^git:\/\//, 'https://')
+            .replace(/^https?:\/\/[^@/]+@/, 'https://') // beágyazott credential levágása
+            .replace(/\.git$/, '')
+            .replace(/\/+$/, '');
+        const nameMatch = url.match(/^https?:\/\/[\w.-]+\/(.+?\/[^/]+)$/);
+        return { url: url, name: nameMatch ? nameMatch[1] : undefined };
+    }
+    /** A `[remote "origin"]` szekció `url = …` sora a `.git/config`-ból (defenzív, szekció-tudatos). */
+    static extractOriginUrl(configText) {
+        let inOrigin = false;
+        for (const rawLine of configText.split(/\r?\n/)) {
+            const line = rawLine.trim();
+            const section = line.match(/^\[remote\s+"([^"]+)"\]$/);
+            if (section) {
+                inOrigin = section[1] === 'origin';
+                continue;
+            }
+            if (line.startsWith('[')) {
+                inOrigin = false;
+                continue;
+            }
+            if (inOrigin) {
+                const url = line.match(/^url\s*=\s*(.+)$/);
+                if (url) {
+                    return url[1].trim();
+                }
+            }
+        }
+        return undefined;
+    }
+    /** A submodule `.git` FÁJL (`gitdir: <relpath>`) feloldása a tényleges git-könyvtárra. */
+    static resolveGitdir(repoRoot, gitFilePath) {
+        try {
+            const content = fs.readFileSync(gitFilePath, 'utf-8').trim();
+            const match = content.match(/^gitdir:\s*(.+)$/);
+            if (match) {
+                const target = match[1].trim();
+                return path.isAbsolute(target) ? target : path.resolve(repoRoot, target);
+            }
+        }
+        catch {
+            /* fall through */
+        }
+        return gitFilePath;
+    }
+}
+exports.FAM_GitRepo_Util = FAM_GitRepo_Util;

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;