@futdevpro/fdp-agent-memory 1.1.12 → 1.1.14

package/build/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@futdevpro/fdp-agent-memory",
-    "version": "1.1.12",
+    "version": "1.1.14",
     "description": "Local-first, vector-backed multi-table agent memory exposed as an MCP server (read/write/capabilities). Public, FDP-Templates-free, no auth.",
     "private": false,
     "publishConfig": {

package/build/src/_cli/_commands/serve.command.js

@@ -1,7 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.FAM_Serve_Util = void 0;
+const tslib_1 = require("tslib");
 const child_process_1 = require("child_process");
+const net = tslib_1.__importStar(require("net"));
 const fs_1 = require("fs");
 const os_1 = require("os");
 const path_1 = require("path");
@@ -147,7 +149,13 @@ class FAM_Serve_Util {
         if (action === 'restart') {
             fam_output_util_1.FAM_Output_Util.logInfo(globals, `FAM szerver RESTART: a(z) ${port} porton futó szerver leállítása…`);
             await FAM_Serve_Util.stopServerOnPort(port);
-            await FAM_Serve_Util.waitForPortDown(client, 8000);
+            // A health-down NEM elég: az új szerver bind-preflight-je a TÉNYLEGESEN SZABAD (bindolható) portot
+            // igényli (a kill utáni process-halál + TIME_WAIT lassú lehet) → a port bindolhatóságát várjuk.
+            const freed = await FAM_Serve_Util.waitForPortFree(port, 12000);
+            if (!freed) {
+                fam_output_util_1.FAM_Output_Util.logInfo(globals, `⚠ a(z) ${port} port 12s alatt nem szabadult fel — az indítás megpróbálom, `
+                    + 'de ha bind-hiba van, futtasd újra a `fam serve --restart`-ot.');
+            }
         }
         return FAM_Serve_Util.spawnServer({ globals: globals, local: local, port: port, healthUrl: healthUrl, client: client });
     }
@@ -265,14 +273,24 @@ class FAM_Serve_Util {
         return false;
     }
     /** A port LE-állásának bevárása (a `--restart` kill után, mielőtt újraindítunk), felső korláttal. */
-    static async waitForPortDown(client, timeoutMs) {
+    static async waitForPortFree(port, timeoutMs) {
         const deadline = Date.now() + timeoutMs;
         while (Date.now() < deadline) {
-            if (!(await client.isReachable(1000))) {
-                return;
+            if (await FAM_Serve_Util.isPortFree(port)) {
+                return true;
             }
             await FAM_Serve_Util.sleep(FAM_Serve_Util.HEALTH_POLL_MS);
         }
+        return false;
+    }
+    /** Bindolható-e (szabad-e) a port? Egy próba-`listen` a loopbackon, azonnali close — `true`, ha köthető. */
+    static isPortFree(port) {
+        return new Promise((resolveCheck) => {
+            const tester = net.createServer();
+            tester.once('error', () => resolveCheck(false));
+            tester.once('listening', () => tester.close(() => resolveCheck(true)));
+            tester.listen(port, '127.0.0.1');
+        });
     }
     /**
      * A megadott porton FIGYELŐ process leállítása (a `--restart` magja). Platform-natív, fail-safe: Windows →
@@ -284,7 +302,12 @@ class FAM_Serve_Util {
         const command = isWin ? (process.env.ComSpec ?? 'powershell.exe') : 'sh';
         const psScript = `$ErrorActionPreference='SilentlyContinue';`
             + `(Get-NetTCPConnection -LocalPort ${port} -State Listen).OwningProcess | Select-Object -Unique | `
-            + `ForEach-Object { Stop-Process -Id $_ -Force }`;
+            + `ForEach-Object { Stop-Process -Id $_ -Force };`
+            // A serve-ablakot (a fam-server-<port>.ps1-t futtató powershell) is leállítjuk → nincs árva,
+            // „[FAM szerver kilépett]" zombi-ablak a restart után (különben halmozódnak).
+            + `Get-CimInstance Win32_Process -Filter "Name='powershell.exe'" | `
+            + `Where-Object { $_.CommandLine -like '*fam-server-${port}*' } | `
+            + `ForEach-Object { Stop-Process -Id $_.ProcessId -Force }`;
         const args = isWin
             ? ['-NoProfile', '-Command', psScript]
             : ['-c', `lsof -ti tcp:${port} | xargs -r kill -9`];

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/_services/fam-ingest.control-service.js

@@ -15,6 +15,7 @@ const fam_reference_code_util_1 = require("../../../_collections/fam-reference-c
 const embedding_1 = require("../../embedding");
 const scope_reference_1 = require("../../scope-reference");
 const fam_content_hash_util_1 = require("../_collections/fam-content-hash.util");
+const fam_git_repo_util_1 = require("../_collections/fam-git-repo.util");
 const fam_project_identity_util_1 = require("../_collections/fam-project-identity.util");
 const fam_scan_path_util_1 = require("../_collections/fam-scan-path.util");
 const fam_scan_progress_util_1 = require("../_collections/fam-scan-progress.util");
@@ -408,6 +409,8 @@ class FAM_Ingest_ControlService {
             headingPath: set.chunk.headingPath,
             source: {
                 type: 'scan', path: set.file.relativePath, root: set.root, absolutePath: set.file.absolutePath,
+                // Git-repo provenance (user-FR): repoUrl + repoRelativePath + repoBranch → kattintható citáció.
+                ...fam_git_repo_util_1.FAM_GitRepo_Util.sourceFieldsFor(set.file.absolutePath),
             },
             addedBy: 'scan',
             ingestRunId: set.runId,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@futdevpro/fdp-agent-memory",
-  "version": "1.1.12",
+  "version": "1.1.14",
   "description": "Local-first, vector-backed multi-table agent memory exposed as an MCP server (read/write/capabilities). Public, FDP-Templates-free, no auth.",
   "private": false,
   "publishConfig": {