fraim 2.0.361 → 2.0.362-next.2

package/dist/src/fraim/db-service.js

@@ -39,6 +39,7 @@ const node_crypto_1 = require("node:crypto");
 const current_license_1 = require("./current-license");
 const git_utils_1 = require("../core/utils/git-utils");
 const quality_evidence_1 = require("../core/quality-evidence");
+const license_presentation_1 = require("./license-presentation");
 function sanitizeSessionRepoContext(repo) {
     if (!repo || typeof repo !== 'object') {
         return repo;
@@ -108,6 +109,7 @@ function removeLabels(existing, labelsToRemove) {
 }
 class FraimDbService {
     constructor() {
+        this.connected = false;
         this.usageEventsCollectionName = 'fraim_usage_events';
         const url = process.env.MONGODB_URI || process.env.MONGO_DATABASE_URL;
         if (!url) {
@@ -116,39 +118,86 @@ class FraimDbService {
         this.uri = url;
         this.dbName = (0, git_utils_1.determineDatabaseName)();
     }
+    /** Driver topology recovery plus one health probe; never runs schema work. */
+    async recoverConnection() {
+        if (!this.recovering) {
+            this.recovering = (async () => {
+                if (!this.client || !this.db)
+                    return this.connect();
+                await this.client.connect();
+                await this.db.command({ ping: 1 });
+            })();
+        }
+        try {
+            await this.recovering;
+        }
+        finally {
+            this.recovering = undefined;
+        }
+    }
     async connect() {
+        if (this.connected)
+            return;
+        if (this.connecting)
+            return this.connecting;
+        this.connecting = this.acquireConnection();
+        try {
+            await this.connecting;
+        }
+        finally {
+            this.connecting = undefined;
+        }
+    }
+    async acquireConnection() {
+        const started = Date.now();
+        const cold = !FraimDbService.connectionPromise;
         FraimDbService.refCount++;
-        if (FraimDbService.connectionPromise) {
+        try {
+            if (!FraimDbService.connectionPromise) {
+                FraimDbService.connectionPromise = (async () => {
+                    const client = new mongodb_1.MongoClient(this.uri);
+                    try {
+                        await client.connect();
+                        FraimDbService.client = client;
+                        FraimDbService.db = client.db(this.dbName);
+                    }
+                    catch (error) {
+                        await client.close();
+                        throw error;
+                    }
+                })();
+            }
             await FraimDbService.connectionPromise;
             this.client = FraimDbService.client;
             this.db = FraimDbService.db;
-            // Ensure per-instance collection handles are initialized when reusing shared connection.
             await this.initializeCollections();
-            return;
+            this.connected = true;
+            console.info(`[FRAIM] connect_ms=${Date.now() - started} cold=${cold}`);
         }
-        FraimDbService.connectionPromise = (async () => {
-            try {
-                if (!FraimDbService.client) {
-                    FraimDbService.client = new mongodb_1.MongoClient(this.uri);
-                    await FraimDbService.client.connect();
-                    FraimDbService.db = FraimDbService.client.db(this.dbName);
+        catch (error) {
+            FraimDbService.refCount = Math.max(0, FraimDbService.refCount - 1);
+            FraimDbService.connectionPromise = undefined;
+            throw error;
+        }
+    }
+    /** Called explicitly by the server before it accepts requests. */
+    async initializeIndexesAtStartup() {
+        if (!this.db)
+            throw new Error('Connect before initializing indexes');
+        if (!FraimDbService.indexInitialization) {
+            FraimDbService.indexInitialization = (async () => {
+                const started = Date.now();
+                const results = await Promise.allSettled([
+                    this.initializeIndexes(), this.initializeUsageEventsCollection(),
+                ]);
+                for (const result of results) {
+                    if (result.status === 'rejected')
+                        console.error('[FRAIM] Startup index initialization failed:', result.reason);
                 }
-                this.client = FraimDbService.client;
-                this.db = FraimDbService.db;
-                console.log(`[FRAIM] Connected to MongoDB: ${this.uri.replace(/:([^:@]+)@/, ':****@')}, Database: ${this.dbName}`);
-                // Initialize collections and indexes
-                await this.initializeCollections();
-                await this.initializeIndexes();
-                await this.initializeUsageEventsCollection();
-                console.log(`✅ Connected to Fraim DB: ${this.dbName}`);
-            }
-            catch (error) {
-                FraimDbService.connectionPromise = undefined;
-                console.error('❌ Failed to connect to MongoDB:', error);
-                throw error;
-            }
-        })();
-        await FraimDbService.connectionPromise;
+                console.info(`[FRAIM] index_init_ms=${Date.now() - started}`);
+            })();
+        }
+        await FraimDbService.indexInitialization;
     }
     async initializeCollections() {
         if (!this.db)
@@ -1332,10 +1381,24 @@ class FraimDbService {
         });
         return latest?.createdAt ?? null;
     }
+    /** Explicit legacy/detail read only; never part of the window-scoped overview. */
+    async getLatestUsageEventsByUser(userIds, types) {
+        if (!this.db)
+            throw new Error('DB not connected');
+        if (!userIds.length)
+            return new Map();
+        const rows = await this.db.collection(this.usageEventsCollectionName).aggregate([
+            { $match: { userId: { $in: userIds }, ...(types?.length ? { type: { $in: types } } : {}) } },
+            { $group: { _id: '$userId', lastEventAt: { $max: '$createdAt' } } },
+        ]).toArray();
+        const latest = new Map(userIds.map(id => [id, null]));
+        for (const row of rows)
+            latest.set(row._id, row.lastEventAt);
+        return latest;
+    }
     /** Keep the earliest observed start per execution before grouping into time buckets. */
     distinctJobStartStages() {
         return [
-            { $sort: { createdAt: 1 } },
             { $group: {
                     _id: { $cond: [
                             { $and: [{ $eq: ['$type', 'job'] }, { $ne: [{ $ifNull: ['$jobId', ''] }, ''] }] },
@@ -1343,11 +1406,105 @@ class FraimDbService {
                             // Preserve legacy event counts when no execution ID is available.
                             '$_id',
                         ] },
-                    event: { $first: '$$ROOT' },
+                    // Array comparison is lexicographic: ID breaks timestamp ties without
+                    // a compound sort (unsupported by Cosmos without another index).
+                    event: { $min: { $concatArrays: [['$createdAt', '$_id', '$name', '$type', '$userId',
+                                    { $ifNull: ['$category', null] }, { $ifNull: ['$success', false] },
+                                    { $ifNull: ['$tokenSnapshot', null] }]] } },
+                } },
+            { $project: {
+                    _id: { $arrayElemAt: ['$event', 1] },
+                    createdAt: { $arrayElemAt: ['$event', 0] },
+                    name: { $arrayElemAt: ['$event', 2] },
+                    type: { $arrayElemAt: ['$event', 3] },
+                    userId: { $arrayElemAt: ['$event', 4] },
+                    category: { $arrayElemAt: ['$event', 5] },
+                    success: { $arrayElemAt: ['$event', 6] },
+                    tokenSnapshot: { $arrayElemAt: ['$event', 7] },
                 } },
-            { $replaceRoot: { newRoot: '$event' } },
         ];
     }
+    /** Window-scoped overview: four queries regardless of the number of members. */
+    async getTeamMemberSummaryData(userIds, timeWindow, repoIdentifier) {
+        if (!this.db)
+            throw new Error('DB not connected');
+        const ids = [...new Set(userIds)];
+        if (!ids.length)
+            return [];
+        const repo = repoIdentifier ? (0, git_utils_1.sanitizeRepoIdentifier)(repoIdentifier) : undefined;
+        const scope = { userId: { $in: ids }, createdAt: this.buildCreatedAtMatch(timeWindow),
+            ...(repo ? { repoIdentifier: repo } : {}) };
+        const events = this.db.collection(this.usageEventsCollectionName);
+        // Execute sequentially to avoid an individual overview multiplying DB concurrency.
+        const totals = await events.aggregate([
+            { $match: { ...scope, type: 'job' } },
+            { $group: { _id: '$userId', totalEvents: { $sum: 1 }, lastEventAt: { $max: '$createdAt' } } },
+        ]).toArray();
+        const components = await events.aggregate([
+            { $match: { ...scope, type: 'job', 'args.action': { $ne: 'complete' }, 'args.isReload': { $ne: true } } },
+            ...this.distinctJobStartStages(),
+            { $group: { _id: { userId: '$userId', name: '$name' },
+                    category: { $min: '$category' }, count: { $sum: 1 } } },
+        ]).toArray();
+        const licenses = await this.db.collection('fraim_api_keys')
+            .find({ userId: { $in: ids.map(id => id.trim().toLowerCase()) } }).toArray();
+        const quality = await this.db.collection('fraim_quality_scores').aggregate([
+            { $match: scope },
+            { $group: {
+                    _id: { userId: '$userId', stage: { $cond: [
+                                { $eq: ['$jobName', 'triage-customer-needs'] }, 'customer-development', '$stageCategory',
+                            ] } },
+                    latest: { $max: { $cond: [
+                                { $in: [{ $type: '$scores.composite' }, ['double', 'int', 'long', 'decimal']] },
+                                ['$createdAt', '$_id', '$scores.composite'], null,
+                            ] } },
+                    gate: { $max: { $cond: [
+                                { $eq: ['$jobName', 'triage-customer-needs'] },
+                                ['$createdAt', '$_id', { $ifNull: ['$scores.gateDecision', null] }, { $ifNull: ['$scores.gaps', []] }], null,
+                            ] } },
+                } },
+        ]).toArray();
+        const totalsByUser = new Map(totals.map(row => [row._id, row]));
+        const componentsByUser = new Map();
+        for (const row of components) {
+            const list = componentsByUser.get(row._id.userId) ?? [];
+            list.push({ name: row._id.name, category: row.category, count: row.count });
+            componentsByUser.set(row._id.userId, list);
+        }
+        const licensesByUser = new Map();
+        for (const key of licenses) {
+            const list = licensesByUser.get(key.userId) ?? [];
+            list.push(key);
+            licensesByUser.set(key.userId, list);
+        }
+        const qualityByUser = new Map();
+        for (const row of quality) {
+            const stages = qualityByUser.get(row._id.userId) ?? new Map();
+            stages.set(row._id.stage, row);
+            qualityByUser.set(row._id.userId, stages);
+        }
+        return ids.map(memberId => {
+            const keys = licensesByUser.get(memberId.trim().toLowerCase()) ?? [];
+            const selected = (0, current_license_1.selectCurrentLicense)(keys, false);
+            // Match the existing single-member revoked-account presentation.
+            const fallback = !selected && keys.length
+                ? { ...[...keys].sort((a, b) => a.key.localeCompare(b.key))[0], status: 'expired' } : null;
+            const total = totalsByUser.get(memberId);
+            const lastEventAt = total?.lastEventAt ?? null;
+            return {
+                memberId, totalEvents: total?.totalEvents ?? 0, lastEventAt, lastActiveAt: lastEventAt,
+                hasFraimSetup: keys.length > 0, ...(0, license_presentation_1.serializeLicenseLifecycle)(selected ?? fallback),
+                components: componentsByUser.get(memberId) ?? [],
+                qualityStages: quality_evidence_1.ALL_STAGE_CATEGORIES.map(stageCategory => {
+                    const row = qualityByUser.get(memberId)?.get(stageCategory);
+                    return { stageCategory, stageName: quality_evidence_1.STAGE_DISPLAY_NAMES[stageCategory] ?? stageCategory,
+                        latestComposite: row?.latest?.[2] ?? null,
+                        latestGate: row?.latest && row?.gate?.[2]
+                            ? { decision: row.gate[2], gaps: row.gate[3] } : null };
+                }),
+            };
+        });
+    }
     /**
      * Get top components by usage count
      */
@@ -1380,17 +1537,19 @@ class FraimDbService {
             {
                 $group: {
                     _id: { name: '$name', type: '$type' },
-                    category: { $first: '$category' },
+                    category: { $min: '$category' },
                     count: { $sum: 1 },
                     successfulEvents: { $sum: { $cond: ['$success', 1, 0] } },
                     lastUsed: { $max: '$createdAt' }
                 }
             },
-            { $sort: { count: -1 } },
-            { $limit: limit }
         ];
         const results = await collection.aggregate(pipeline).toArray();
-        return results.map(result => ({
+        // Sorting tied counts in memory avoids a Cosmos compound ORDER BY while
+        // keeping the limit boundary stable across repeated refreshes.
+        results.sort((a, b) => b.count - a.count || String(a._id.name).localeCompare(String(b._id.name))
+            || String(a._id.type).localeCompare(String(b._id.type)));
+        return results.slice(0, limit).map(result => ({
             name: result._id.name,
             type: result._id.type,
             category: result.category,
@@ -1544,7 +1703,7 @@ class FraimDbService {
                         date: { $dateToString: { format, date: '$createdAt' } },
                         name: '$name'
                     },
-                    category: { $first: '$category' },
+                    category: { $min: '$category' },
                     count: { $sum: 1 },
                     successRate: { $avg: { $cond: ['$success', 100, 0] } },
                     minDate: { $min: '$createdAt' },
@@ -1578,7 +1737,9 @@ class FraimDbService {
             },
             { $sort: { date: 1 } }
         ];
-        return await collection.aggregate(pipeline).toArray();
+        const results = await collection.aggregate(pipeline).toArray();
+        return results.sort((a, b) => new Date(a.date).getTime() - new Date(b.date).getTime()
+            || String(a.name).localeCompare(String(b.name)));
     }
     async getComponentTrend(componentName, componentType, timeWindow, userId, dateUnit, repoIdentifier) {
         if (!this.db)
@@ -1724,6 +1885,9 @@ class FraimDbService {
         return {};
     }
     async close() {
+        if (!this.connected)
+            return;
+        this.connected = false;
         FraimDbService.refCount = Math.max(0, FraimDbService.refCount - 1);
         if (FraimDbService.refCount === 0 && FraimDbService.client) {
             await FraimDbService.client.close();
@@ -1731,6 +1895,8 @@ class FraimDbService {
             FraimDbService.db = undefined;
             FraimDbService.connectionPromise = undefined;
         }
+        this.client = undefined;
+        this.db = undefined;
     }
     getClient() {
         return FraimDbService.client;
@@ -1964,16 +2130,17 @@ class FraimDbService {
         const collection = this.db.collection('fraim_quality_scores');
         const sanitizedRepo = repoIdentifier ? (0, git_utils_1.sanitizeRepoIdentifier)(repoIdentifier) : undefined;
         const createdAtFilter = this.buildQualityCreatedAtFilter(periodDays, startDate, endDate);
-        // All stage queries + the gate findOne start concurrently in a single Promise.all.
-        const [stageResults, gateScore] = await Promise.all([
-            Promise.all(quality_evidence_1.ALL_STAGE_CATEGORIES.map(stageCategory => collection
-                .find({ userId, stageCategory, ...(sanitizedRepo ? { repoIdentifier: sanitizedRepo } : {}), ...createdAtFilter })
-                .sort({ createdAt: 1 })
-                .limit(100)
-                .toArray()
-                .then(scores => ({ stageCategory, scores })))),
-            collection.findOne({ userId, jobName: 'triage-customer-needs', ...(sanitizedRepo ? { repoIdentifier: sanitizedRepo } : {}), ...createdAtFilter }, { sort: { createdAt: -1 } }),
-        ]);
+        const records = await collection.find({ userId,
+            ...(sanitizedRepo ? { repoIdentifier: sanitizedRepo } : {}), ...createdAtFilter,
+        }).toArray();
+        // Match the overview's deterministic latest selection, including histories
+        // longer than 100 entries. Sort locally to avoid a Cosmos compound sort.
+        records.sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+            || String(b._id).localeCompare(String(a._id)));
+        const gateScore = records.find(record => record.jobName === 'triage-customer-needs');
+        const stageResults = quality_evidence_1.ALL_STAGE_CATEGORIES.map(stageCategory => ({ stageCategory,
+            scores: this.recentQualityAssessments(records.filter(record => record.stageCategory === stageCategory)),
+        }));
         const stages = stageResults.map(({ stageCategory, scores }) => {
             // Filter to records that have an actual composite score — some records
             // (e.g., triage-customer-needs gate decisions) intentionally omit composite
@@ -2028,6 +2195,13 @@ class FraimDbService {
         });
         return stages;
     }
+    /** Both tiles and detail show the latest 100 scored assessments, chronologically. */
+    recentQualityAssessments(records) {
+        return records.filter(record => typeof record.scores?.composite === 'number')
+            .sort((a, b) => new Date(b.createdAt).getTime() - new Date(a.createdAt).getTime()
+            || String(b._id).localeCompare(String(a._id)))
+            .slice(0, 100).reverse();
+    }
     /**
      * Get full assessment history for a single stage (tile click detail view).
      */
@@ -2036,11 +2210,10 @@ class FraimDbService {
             throw new Error('DB not connected');
         const sanitizedRepo = repoIdentifier ? (0, git_utils_1.sanitizeRepoIdentifier)(repoIdentifier) : undefined;
         const createdAtFilter = this.buildQualityCreatedAtFilter(periodDays, startDate, endDate);
-        const scores = await this.db.collection('fraim_quality_scores')
+        const records = await this.db.collection('fraim_quality_scores')
             .find({ userId, stageCategory, ...(sanitizedRepo ? { repoIdentifier: sanitizedRepo } : {}), ...createdAtFilter })
-            .sort({ createdAt: 1 })
-            .limit(100)
             .toArray();
+        const scores = this.recentQualityAssessments(records);
         const composites = scores.map(s => s.scores.composite ?? 0);
         const avgComposite = composites.length > 0
             ? Math.round(composites.reduce((a, b) => a + b, 0) / composites.length * 10) / 10