@futdevpro/fdp-agent-memory 1.1.30 → 1.1.113

package/build/src/_routes/server/api/fam-doctor.control-service.js

@@ -0,0 +1,156 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FAM_Doctor_ControlService = void 0;
+const mcp_1 = require("../../../_modules/mcp");
+const scope_reference_1 = require("../../../_modules/scope-reference");
+/** A 6 doctor al-check ↔ capability-eszköz mátrix (dsgn-010 §5.2; a `fam doctor` CLI-mátrixával egyező). */
+const CHECK_MATRIX = [
+    { name: 'env', capability: 'validate_environment', fixHint: 'Hiányzó env (pl. MONGODB_URI) → `fam init` vagy állítsd be a `.env`-ben.' },
+    { name: 'mongodb', capability: 'test_mongodb_connection', fixHint: 'Mongo nem elérhető → indítsd a Mongo-t, ellenőrizd a portot / MONGODB_URI-t.' },
+    { name: 'config', capability: 'get_config_status', fixHint: 'Nincs fam_config global rekord → `fam init` vagy `fam config set …`.' },
+    { name: 'embedding', capability: 'test_embedding_provider', fixHint: 'OpenAI 401 → ellenőrizd OPENAI_API_KEY-t; LM Studio: indítsd a szervert + tölts be modellt.' },
+    { name: 'vector', capability: 'test_vector_search', fixHint: 'Vektor-pool üres/nem-hidratált → `fam write … re-embed` vagy ellenőrizd a Mongo-persist réteget.' },
+    { name: 'collections', capability: 'get_table_stats', fixHint: 'Hiányzó collection → indítsd a szervert egyszer (auto-create), majd `fam doctor`.' },
+];
+/**
+ * `FAM_Doctor_ControlService` (#2 diagnosztikai végpont, user-FR 2026-06-24) — a `fam doctor` aggregátorának
+ * **SZERVER-OLDALI** változata (server-centric / thin-CLI, ADR-015). A 6 capability-diagnosztikát IN-PROCESS futtatja
+ * (`FAM_CapabilitiesTool_Service.handle`, nem HTTP-round-trip), és aggregált health-report-ot ad (+ best-effort
+ * scope-integritás). A `/api/doctor` ezt szolgálja ki; a CLI/kliens/UI/külső eszköz ezt hívhatja (nem 6 külön
+ * capability-hívást). Az `interpret` PURE (a capability szemantikus hiba-jelzéseit — `available/reachable/ok:false`,
+ * `missing[]` — fail-ként ismeri fel, nem csak a throw-t; a CLI csak a throw-t fogta).
+ */
+class FAM_Doctor_ControlService {
+    static _instance;
+    static getInstance() {
+        if (!FAM_Doctor_ControlService._instance) {
+            FAM_Doctor_ControlService._instance = new FAM_Doctor_ControlService();
+        }
+        return FAM_Doctor_ControlService._instance;
+    }
+    /**
+     * A capability-eredmény SZEMANTIKUS hiba-jelzése (PURE, tesztelhető): a technikailag sikeres hívás is jelezhet
+     * hibát (`available:false` = embedding down; `reachable:false` = Mongo down; `ok:false`; `missing[]` = hiányzó env).
+     * A wrapper-réteget (`data`/`result`) is megnézi. `true` = egészségtelen (→ FAIL).
+     */
+    static interpretUnhealthy(result) {
+        const root = (result && typeof result === 'object') ? result : {};
+        const inner = root.data ?? root.result ?? root;
+        const flat = (inner && typeof inner === 'object') ? inner : root;
+        return flat.available === false
+            || flat.reachable === false
+            || flat.ok === false
+            || (Array.isArray(flat.missing) && flat.missing.length > 0);
+    }
+    /** A teljes (vagy `skip`-elt) check-szett lefuttatása + aggregált health-report. */
+    async runDoctor(set) {
+        const skip = set?.skip ?? [];
+        const checks = [];
+        for (const descriptor of CHECK_MATRIX) {
+            if (skip.includes(descriptor.name)) {
+                continue;
+            }
+            checks.push(await this.runCheck(descriptor));
+        }
+        const summary = { ok: 0, warn: 0, fail: 0 };
+        for (const check of checks) {
+            summary[check.status] += 1;
+        }
+        const health = summary.fail ? 'fail' : summary.warn ? 'warn' : 'ok';
+        return {
+            health: health,
+            checks: checks,
+            summary: summary,
+            scopeIntegrity: await this.scopeIntegrity(),
+            database: await this.databaseInfo(),
+        };
+    }
+    /**
+     * Best-effort DB-diagnosztika (user-FR 2026-06-24): a 6 fő tár elem-számai + embedding-státusza (get_table_stats)
+     * + a helper-collection-ök mérete + az összes aktív doc (get_storage_usage). A hiba NEM buktatja a report-ot.
+     */
+    async databaseInfo() {
+        try {
+            const statsRaw = await mcp_1.FAM_CapabilitiesTool_Service.getInstance().handle({ action: 'invoke', name: 'get_table_stats' });
+            const storageRaw = await mcp_1.FAM_CapabilitiesTool_Service.getInstance().handle({ action: 'invoke', name: 'get_storage_usage' });
+            const statsList = FAM_Doctor_ControlService.unwrapArray(statsRaw);
+            const storage = FAM_Doctor_ControlService.unwrapRecord(storageRaw);
+            const tables = (Array.isArray(statsList) ? statsList : []).map((raw) => {
+                const item = (raw && typeof raw === 'object') ? raw : {};
+                const es = (item.embeddingStatus && typeof item.embeddingStatus === 'object')
+                    ? item.embeddingStatus : {};
+                return {
+                    table: String(item.table ?? ''),
+                    count: Number(item.count) || 0,
+                    completed: Number(es.completed) || 0,
+                    pending: Number(es.pending) || 0,
+                    error: Number(es.error) || 0,
+                };
+            });
+            const mainCollections = /^fam_(rules|documents|codebases|knowledges|coding_patterns|memories)$/;
+            const collectionsRaw = storage.collections;
+            const helperCollections = (Array.isArray(collectionsRaw) ? collectionsRaw : [])
+                .map((raw) => {
+                const item = (raw && typeof raw === 'object') ? raw : {};
+                return { collection: String(item.collection ?? ''), activeDocs: Number(item.activeDocs) || 0 };
+            })
+                .filter((entry) => entry.collection && !mainCollections.test(entry.collection));
+            return {
+                tables: tables,
+                totalActiveDocs: typeof storage.totalActiveDocs === 'number' ? storage.totalActiveDocs : undefined,
+                helperCollections: helperCollections,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /** A capability-eredmény tömb-payloadja (a `this.ok` wrapper-réteget is megnézve). */
+    static unwrapArray(result) {
+        if (Array.isArray(result)) {
+            return result;
+        }
+        const root = (result && typeof result === 'object') ? result : {};
+        const inner = root.data ?? root.result ?? root;
+        return Array.isArray(inner) ? inner : [];
+    }
+    /** A capability-eredmény objektum-payloadja (a `this.ok` wrapper-réteget is megnézve). */
+    static unwrapRecord(result) {
+        const root = (result && typeof result === 'object') ? result : {};
+        const inner = root.data ?? root.result ?? root;
+        return (inner && typeof inner === 'object') ? inner : root;
+    }
+    /** Egy capability-check IN-PROCESS futtatása → `FAM_DoctorCheck` (throw → FAIL/WARN; szemantikus hiba → FAIL). */
+    async runCheck(descriptor) {
+        try {
+            const result = await mcp_1.FAM_CapabilitiesTool_Service.getInstance()
+                .handle({ action: 'invoke', name: descriptor.capability });
+            if (FAM_Doctor_ControlService.interpretUnhealthy(result)) {
+                return { name: descriptor.name, status: 'fail', detail: JSON.stringify(result).slice(0, 240), fixHint: descriptor.fixHint };
+            }
+            return { name: descriptor.name, status: 'ok' };
+        }
+        catch (error) {
+            const message = error?.message ?? 'ismeretlen hiba';
+            // A late-bind eszközök clear "pending MP-X" hibája → WARN (nem FAIL, nem néma).
+            const isPending = message.toLowerCase().includes('pending');
+            return { name: descriptor.name, status: isPending ? 'warn' : 'fail', detail: message, fixHint: descriptor.fixHint };
+        }
+    }
+    /** Best-effort scope-integritás-összegzés (a detect_scope_issues hibája NEM buktatja a doctor-report-ot). */
+    async scopeIntegrity() {
+        try {
+            const issues = await scope_reference_1.FAM_ScopeMaintenance_ControlService.getInstance().detectIssues();
+            return {
+                hasIssues: issues.hasIssues,
+                orphanScopes: issues.orphanProjectScopes.length,
+                duplicateScopes: issues.duplicateScopes.length,
+                repoKeyDuplicates: issues.repoKeyDuplicates.length,
+            };
+        }
+        catch {
+            return undefined;
+        }
+    }
+}
+exports.FAM_Doctor_ControlService = FAM_Doctor_ControlService;

package/build/src/app.server.js

@@ -53,14 +53,17 @@ class App extends nts_dynamo_1.DyNTS_App {
         nts_dynamo_1.DyNTS_global_settings.log_settings.logs_endpoint = { enabled: true };
         logs_1.DyNTS_Logs_Service.getInstance().install();
         // OOM-hibakezelés a BEDROCK `DyNTS_MemoryGuard`-ból (a base App auto-installálja a startup-ban). FAM-specifikus
-        // hangolás: a GC-thrash a fő OOM-jel (a FAM korpusza nagy, a heap-% csak ~85%-on ütött, de GC ~0.87-en thrash-elt),
-        // ezért a GC-fraction-küszöbök a kritikusak; a `%`-küszöböt magasra tesszük (csak genuine-danger). A critical
-        // nyomás load-shed-eli a nehéz write-eket (scan/import) az api-controllerben, + crash-handler (uncaughtException →
-        // teljes-részletű error-entry) ON. **`exitOnSustainedCritical` ON** (nts-dynamo 1.15.74 boot-grace-szel): a FAM
-        // boot-hidratálása (126k vektor) ELEVE GC-thrash-el (mért gc≈0.87), ezért `bootGraceMs: 120000` — a ~80s hidratálás
-        // + margó alatt a sustained-critical NEM lép ki (csak logol + load-shed); a grace UTÁN a tartós critical TISZTÁN
-        // kilép (exit 137) → a `fam serve` ps1-wrapper prediktíven újraindít (a kriptikus OOM exit-134 helyett). Az eredeti
-        // OOM uptime 771s-nél volt — jóval a grace után, tehát kezelve.
+        // hangolás. **LELET (2026-06-22, L6 full-workspace scan):** a GC-fraction-alapú kritikusság ÖNMAGÁBAN
+        // FALSE-POSITIVE a bulk-embedding alatt — a guard 33–43% heap-nél (5–7 GB / 16 GB, rengeteg szabad) lőtt ki,
+        // mert a tömeges embedding természetes throughput-churn-je GC-fraction 100%-ra ugratja. Ez NEM OOM-precursor:
+        // a GC-thrash CSAK a heap-plafon közelében (~≥85%) valódi OOM-jel (akkor nem tud felszabadítani). 43% heap-en a
+        // V8-nak 9+ GB tartaléka van. Az `exitOnSustainedCritical` ezért egészséges szervert ölt → ~100s rehidratálás
+        // (most 248k vektor) → a scan-CLI a holt-ablakban projekteket veszít (L6: 36/49 „szerver-down"). **JAVÍTÁS:** a
+        // GC-fraction-küszöböt ELÉRHETETLENRE tesszük (`gcCriticalFraction: 1.01`, `gcWarningFraction: 0.95`) → a guard a
+        // HEAP-%-ra támaszkodik (heap-warn 80 / heap-crit 90), aminek itt hatalmas tartaléka van (43% csúcs). A valódi
+        // heap-OOM-védelem + graceful-exit(137) MEGMARAD (csak genuine heap≥90%-nál lép ki, a kriptikus 134 helyett),
+        // de a scan-embedding GC-thrash-ét IGNORÁLJA. **TODO (bedrock, futás után):** a GC-kritikusságot heap-%-hez
+        // KÖTNI (`gcCriticalMinHeapPct`, pl. ≥75%) — akkor a GC-jel újra bekapcsolható, mert csak a plafon közelében hat.
         nts_dynamo_1.DyNTS_global_settings.memoryGuard = {
             enabled: true,
             pollIntervalMs: 3000,
@@ -68,8 +71,8 @@ class App extends nts_dynamo_1.DyNTS_App {
             heapCriticalThreshold: 90,
             recoveryMargin: 10,
             maxHistoryCount: 100,
-            gcWarningFraction: 0.40,
-            gcCriticalFraction: 0.60,
+            gcWarningFraction: 0.95,
+            gcCriticalFraction: 1.01,
             installCrashHandlers: true,
             exitOnSustainedCritical: true,
             sustainedCriticalPolls: 3,