fraim 2.0.361 → 2.0.362-next.2

package/dist/src/services/analytics-read.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyticsReadQueue = void 0;
+exports.analyticsRetryAfterMs = analyticsRetryAfterMs;
+exports.analyticsReadErrorResponse = analyticsReadErrorResponse;
+/** Admission and retry belong to analytics reads, never telemetry writes. */
+function analyticsRetryAfterMs(error) {
+    const message = String(error?.message || '');
+    if (error?.code !== 16500 && error?.code !== 429 && error?.status !== 429 &&
+        error?.statusCode !== 429 && !/TooManyRequests|\b429\b/.test(message))
+        return undefined;
+    const delay = Number(error?.RetryAfterMs ?? error?.retryAfterMs ??
+        message.match(/RetryAfterMs\s*[=:]\s*(\d+)/i)?.[1] ?? 100);
+    return Number.isFinite(delay) && delay >= 0 ? delay : 100;
+}
+/** Keep retry advice and public error messages consistent across analytics routes. */
+function analyticsReadErrorResponse(error) {
+    const status = [400, 401, 403, 404, 503].includes(error?.status) ? error.status : 500;
+    const headers = {};
+    if (status === 503 && error.retryAfterSeconds)
+        headers['Retry-After'] = String(error.retryAfterSeconds);
+    return { status, headers, body: { error: status === 500 ? 'Internal server error' : error.message } };
+}
+class AnalyticsReadQueue {
+    constructor(concurrency = 4) {
+        this.concurrency = concurrency;
+        this.active = 0;
+        this.waiting = [];
+        if (!Number.isInteger(concurrency) || concurrency < 1)
+            throw new Error('Invalid read concurrency');
+    }
+    async run(read) {
+        if (this.active >= this.concurrency)
+            await new Promise(resolve => this.waiting.push(resolve));
+        else
+            this.active++;
+        try {
+            for (let attempt = 0;; attempt++) {
+                try {
+                    return await read();
+                }
+                catch (error) {
+                    const delay = analyticsRetryAfterMs(error);
+                    if (delay === undefined)
+                        throw error;
+                    console.info(`[analytics] throttle=429 attempt=${attempt + 1} retry_after_ms=${delay}`);
+                    // Do not retry early when Cosmos asks for a longer pause than
+                    // this request's bounded retry budget. Return that pause to the caller.
+                    if (attempt >= 2 || delay > 2000) {
+                        throw Object.assign(new Error('Analytics is busy. Please retry shortly.'), {
+                            status: 503, retryAfterSeconds: Math.max(1, Math.ceil(delay / 1000)), cause: error,
+                        });
+                    }
+                    await new Promise(resolve => setTimeout(resolve, delay));
+                }
+            }
+        }
+        finally {
+            const next = this.waiting.shift();
+            if (next)
+                next();
+            else
+                this.active--;
+        }
+    }
+}
+exports.AnalyticsReadQueue = AnalyticsReadQueue;

package/dist/src/services/usage-analytics-service.js

@@ -206,6 +206,27 @@ class UsageAnalyticsService {
         }
         return dominant;
     }
+    async getTeamMemberSummaries(period, userIds, repoIdentifier, startDate, endDate) {
+        const data = await this.dbService.getTeamMemberSummaryData(userIds, this.resolveTimeWindow(period, startDate, endDate), repoIdentifier);
+        // Resolve each distinct job once; historical categories follow the current catalog.
+        const categories = new Map();
+        for (const row of data) {
+            for (const component of row.components) {
+                const key = JSON.stringify([component.name, component.category]);
+                if (!categories.has(key))
+                    categories.set(key, await this.resolveCanonicalCategory(component.name, 'job', component.category) || 'uncategorized');
+            }
+        }
+        return data.map(({ components, ...summary }) => {
+            const totals = new Map();
+            for (const component of components) {
+                const category = categories.get(JSON.stringify([component.name, component.category])) || 'uncategorized';
+                totals.set(category, (totals.get(category) ?? 0) + component.count);
+            }
+            const dominant = [...totals].sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))[0];
+            return { ...summary, dominantCategory: dominant?.[0] ?? null, dominantCategoryCount: dominant?.[1] ?? 0 };
+        });
+    }
     /**
      * Export usage data as CSV
      */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fraim",
-  "version": "2.0.361",
+  "version": "2.0.362-next.2",
   "description": "FRAIM core CLI and MCP package.",
   "main": "index.js",
   "bin": {