@yasserkhanorg/e2e-agents 1.8.4 → 1.9.5

package/dist/esm/knowledge/kg_bridge.js

@@ -0,0 +1,381 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+/**
+ * Bridge between Understand-Anything's knowledge graph and e2e-agents' route families.
+ * Transforms KG nodes/edges into RouteFamilyManifest so existing pipeline works unchanged.
+ */
+import { existsSync, readFileSync } from 'fs';
+import { join } from 'path';
+import { logger } from '../logger.js';
+import { deriveClusterId, deriveClusterIdFromPath } from './cluster_utils.js';
+const UA_DIR = '.understand-anything';
+const KG_FILE = 'knowledge-graph.json';
+const DIFF_FILE = 'diff-overlay.json';
+const FRONTEND_FRAMEWORKS = new Set([
+    'react', 'vue', 'angular', 'svelte', 'next', 'nextjs', 'next.js',
+    'nuxt', 'nuxtjs', 'gatsby', 'remix', 'astro', 'solid', 'solidjs',
+    'preact', 'lit', 'stencil', 'qwik',
+]);
+const BACKEND_FRAMEWORKS = new Set([
+    'express', 'fastify', 'koa', 'hapi', 'nest', 'nestjs',
+    'django', 'flask', 'fastapi', 'rails', 'spring', 'gin', 'echo', 'fiber',
+    'actix', 'axum', 'rocket', 'phoenix', 'laravel',
+]);
+/**
+ * Loads the knowledge graph from .understand-anything/knowledge-graph.json
+ * or from a custom path when provided.
+ */
+export function loadKnowledgeGraph(projectRoot, customPath) {
+    const kgPath = customPath || join(projectRoot, UA_DIR, KG_FILE);
+    if (!existsSync(kgPath)) {
+        return null;
+    }
+    try {
+        const raw = JSON.parse(readFileSync(kgPath, 'utf-8'));
+        if (!raw.nodes || !Array.isArray(raw.nodes) || !raw.edges || !Array.isArray(raw.edges)) {
+            logger.warn('Knowledge graph missing required nodes/edges arrays');
+            return null;
+        }
+        if (!raw.project) {
+            logger.warn('Knowledge graph missing project metadata');
+            return null;
+        }
+        // Field-level validation: filter out invalid nodes rather than rejecting the whole graph
+        const MAX_STRING_LEN = 1000;
+        const validNodes = raw.nodes.filter((node) => {
+            if (typeof node.id !== 'string' || typeof node.name !== 'string') {
+                logger.warn(`Dropping KG node with missing/invalid id or name: ${JSON.stringify(node).slice(0, 200)}`);
+                return false;
+            }
+            if (node.filePath !== undefined) {
+                if (typeof node.filePath !== 'string') {
+                    logger.warn(`Dropping KG node "${node.id}": filePath is not a string`);
+                    return false;
+                }
+                if (node.filePath.startsWith('/')) {
+                    logger.warn(`Dropping KG node "${node.id}": absolute filePath rejected`);
+                    return false;
+                }
+                if (node.filePath.includes('..')) {
+                    logger.warn(`Dropping KG node "${node.id}": path traversal in filePath rejected`);
+                    return false;
+                }
+                if (node.filePath.includes('\0')) {
+                    logger.warn(`Dropping KG node "${node.id}": null byte in filePath rejected`);
+                    return false;
+                }
+            }
+            return true;
+        });
+        // Truncate excessively long strings
+        for (const node of validNodes) {
+            if (node.name.length > MAX_STRING_LEN) {
+                node.name = node.name.slice(0, MAX_STRING_LEN);
+            }
+            if (node.description && node.description.length > MAX_STRING_LEN) {
+                node.description = node.description.slice(0, MAX_STRING_LEN);
+            }
+        }
+        raw.nodes = validNodes;
+        return raw;
+    }
+    catch (error) {
+        logger.warn(`Failed to load knowledge graph: ${error instanceof Error ? error.message : String(error)}`);
+        return null;
+    }
+}
+/**
+ * Classifies project type based on KG framework metadata.
+ */
+export function classifyProjectType(kg) {
+    const frameworks = kg.project.frameworks.map((f) => f.toLowerCase());
+    const hasFrontend = frameworks.some((f) => FRONTEND_FRAMEWORKS.has(f));
+    const hasBackend = frameworks.some((f) => BACKEND_FRAMEWORKS.has(f));
+    if (hasFrontend && hasBackend)
+        return 'fullstack';
+    if (hasBackend)
+        return 'backend';
+    return 'frontend';
+}
+/**
+ * Core bridge: transforms KG into a RouteFamilyManifest.
+ *
+ * Strategy:
+ * - Frontend: cluster UI-layer nodes into families by module/component groups
+ * - Backend: cluster API-layer nodes, follow calls edges into Service→Data layers
+ * - Priority: P0 = high fan-in nodes, P1 = moderate, P2 = leaf/utility
+ * - userFlows: derived from KG tour steps referencing family nodes
+ */
+export function transformKGToFamilies(kg) {
+    const projectType = classifyProjectType(kg);
+    const nodeMap = new Map(kg.nodes.map((n) => [n.id, n]));
+    const edgesByTarget = groupEdges(kg.edges, 'target');
+    // Build clusters based on project type
+    const clusters = buildClusters(kg, projectType, nodeMap);
+    // Transform clusters into route families
+    const families = [];
+    for (const [clusterId, nodeIds] of clusters) {
+        const nodes = nodeIds.map((id) => nodeMap.get(id)).filter((n) => n !== undefined);
+        if (nodes.length === 0)
+            continue;
+        const family = buildFamilyFromCluster(clusterId, nodes, projectType, nodeMap, edgesByTarget);
+        if (family) {
+            families.push(family);
+        }
+    }
+    // Derive userFlows from KG tour steps
+    if (kg.tour && kg.tour.length > 0) {
+        assignTourFlows(families, kg.tour, nodeMap);
+    }
+    // Sort by priority (P0 first) then alphabetically
+    families.sort((a, b) => {
+        const pOrder = { P0: 0, P1: 1, P2: 2 };
+        const pa = pOrder[a.priority || 'P2'];
+        const pb = pOrder[b.priority || 'P2'];
+        if (pa !== pb)
+            return pa - pb;
+        return a.id.localeCompare(b.id);
+    });
+    return {
+        families,
+        source: 'knowledge-graph',
+    };
+}
+/**
+ * Loads the diff overlay from .understand-anything/diff-overlay.json
+ */
+export function loadDiffOverlay(projectRoot) {
+    const overlayPath = join(projectRoot, UA_DIR, DIFF_FILE);
+    if (!existsSync(overlayPath)) {
+        return null;
+    }
+    try {
+        const raw = JSON.parse(readFileSync(overlayPath, 'utf-8'));
+        if (!raw.changes || !Array.isArray(raw.changes)) {
+            return null;
+        }
+        return raw;
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Maps diff overlay changes to file paths using KG node resolution.
+ */
+export function diffOverlayToChangedFiles(overlay, kg) {
+    const nodeMap = new Map(kg.nodes.map((n) => [n.id, n]));
+    const files = new Set();
+    for (const change of overlay.changes) {
+        // Use filePath from change if available
+        if (change.filePath) {
+            files.add(change.filePath);
+            continue;
+        }
+        // Fall back to KG node's filePath
+        const node = nodeMap.get(change.nodeId);
+        if (node?.filePath) {
+            files.add(node.filePath);
+        }
+    }
+    return [...files];
+}
+// ---------------------------------------------------------------------------
+// Internal helpers
+// ---------------------------------------------------------------------------
+function groupEdges(edges, key) {
+    const map = new Map();
+    for (const edge of edges) {
+        const val = edge[key];
+        if (!map.has(val))
+            map.set(val, []);
+        map.get(val).push(edge);
+    }
+    return map;
+}
+/**
+ * Build clusters of related nodes to become families.
+ * Frontend: group by route/page/component modules
+ * Backend: group by API endpoint handlers + their service dependencies
+ */
+function buildClusters(kg, projectType, nodeMap) {
+    const clusters = new Map();
+    // Strategy 1: Use KG layers to find anchor nodes
+    const layerMap = new Map();
+    if (kg.layers) {
+        for (const layer of kg.layers) {
+            layerMap.set(layer.name, new Set(layer.nodeIds));
+        }
+    }
+    // Strategy 2: Group by module/component/route nodes
+    const anchorKinds = projectType === 'backend'
+        ? new Set(['module', 'route', 'class', 'function'])
+        : new Set(['component', 'route', 'module', 'class']);
+    const anchorLayers = projectType === 'backend'
+        ? new Set(['api', 'service'])
+        : new Set(['ui']);
+    for (const node of kg.nodes) {
+        // Skip test/infra nodes as cluster anchors
+        if (node.layer === 'test' || node.layer === 'infra')
+            continue;
+        const isAnchorKind = anchorKinds.has(node.kind);
+        const isAnchorLayer = !node.layer || anchorLayers.has(node.layer);
+        if (!isAnchorKind || !isAnchorLayer)
+            continue;
+        // Derive cluster ID from node path or name
+        const clusterId = deriveClusterId(node);
+        if (!clusterId)
+            continue;
+        if (!clusters.has(clusterId)) {
+            clusters.set(clusterId, []);
+        }
+        clusters.get(clusterId).push(node.id);
+    }
+    // If no clusters found, fall back to file-based grouping
+    if (clusters.size === 0) {
+        for (const node of kg.nodes) {
+            if (!node.filePath || node.layer === 'test' || node.layer === 'infra')
+                continue;
+            const clusterId = deriveClusterIdFromPath(node.filePath);
+            if (!clusterId)
+                continue;
+            if (!clusters.has(clusterId)) {
+                clusters.set(clusterId, []);
+            }
+            clusters.get(clusterId).push(node.id);
+        }
+    }
+    return clusters;
+}
+// deriveClusterId and deriveClusterIdFromPath imported from cluster_utils.ts
+function computePriority(nodes) {
+    const maxFanIn = Math.max(...nodes.map((n) => n.fanIn || 0));
+    if (maxFanIn >= 10)
+        return 'P0';
+    if (maxFanIn >= 4)
+        return 'P1';
+    return 'P2';
+}
+function buildFamilyFromCluster(clusterId, nodes, projectType, nodeMap, edgesByTarget) {
+    const webappPaths = new Set();
+    const serverPaths = new Set();
+    const routes = [];
+    const apiEndpoints = [];
+    for (const node of nodes) {
+        if (!node.filePath)
+            continue;
+        const layer = node.layer;
+        if (layer === 'api' || layer === 'service' || layer === 'data') {
+            serverPaths.add(`${node.filePath}*`);
+        }
+        else if (layer === 'ui') {
+            webappPaths.add(`${node.filePath}*`);
+        }
+        else {
+            // Auto-assign based on project type
+            if (projectType === 'backend') {
+                serverPaths.add(`${node.filePath}*`);
+            }
+            else {
+                webappPaths.add(`${node.filePath}*`);
+            }
+        }
+        // Extract routes from route nodes
+        if (node.kind === 'route') {
+            const routePath = node.metadata?.path;
+            if (routePath) {
+                routes.push(routePath);
+                // Extract API endpoint info
+                const method = node.metadata?.method || 'GET';
+                apiEndpoints.push({ method: method.toUpperCase(), path: routePath, description: node.description });
+            }
+            else {
+                routes.push(`/${clusterId}`);
+            }
+        }
+    }
+    // If no routes extracted, generate a default
+    if (routes.length === 0) {
+        routes.push(`/${clusterId}`);
+    }
+    // Collect related test file paths by following 'tests' edges
+    const specDirs = new Set();
+    for (const node of nodes) {
+        const testEdges = (edgesByTarget.get(node.id) || []).filter((e) => e.type === 'tests');
+        for (const edge of testEdges) {
+            const testNode = nodeMap.get(edge.source);
+            if (testNode?.filePath) {
+                // Use directory of test file
+                const dir = testNode.filePath.replace(/\\/g, '/').split('/').slice(0, -1).join('/');
+                if (dir)
+                    specDirs.add(`${dir}/*`);
+            }
+        }
+    }
+    const priority = computePriority(nodes);
+    // Determine test type based on content
+    let testType;
+    if (webappPaths.size > 0 && serverPaths.size > 0) {
+        testType = 'both';
+    }
+    else if (serverPaths.size > 0 && apiEndpoints.length > 0) {
+        testType = 'api';
+    }
+    else if (webappPaths.size > 0) {
+        testType = 'ui';
+    }
+    const family = {
+        id: clusterId,
+        routes: [...new Set(routes)],
+        priority,
+    };
+    if (webappPaths.size > 0)
+        family.webappPaths = [...webappPaths];
+    if (serverPaths.size > 0)
+        family.serverPaths = [...serverPaths];
+    if (specDirs.size > 0)
+        family.specDirs = [...specDirs];
+    if (apiEndpoints.length > 0)
+        family.apiEndpoints = apiEndpoints;
+    if (testType)
+        family.testType = testType;
+    return family;
+}
+function assignTourFlows(families, tour, nodeMap) {
+    if (!tour)
+        return;
+    // Build a map of nodeId → family for quick lookup
+    const nodeToFamily = new Map();
+    for (const family of families) {
+        // Resolve family nodes from paths
+        for (const [nodeId, node] of nodeMap) {
+            if (!node.filePath)
+                continue;
+            const matchesPaths = [
+                ...(family.webappPaths || []),
+                ...(family.serverPaths || []),
+            ];
+            for (const pattern of matchesPaths) {
+                const prefix = pattern.replace(/\*$/, '');
+                if (node.filePath.startsWith(prefix)) {
+                    nodeToFamily.set(nodeId, family);
+                    break;
+                }
+            }
+        }
+    }
+    // Assign tour steps as user flows
+    for (const step of tour.sort((a, b) => a.order - b.order)) {
+        for (const nodeId of step.nodeIds) {
+            const family = nodeToFamily.get(nodeId);
+            if (family) {
+                if (!family.userFlows)
+                    family.userFlows = [];
+                const flowDesc = `${step.title}: ${step.description}`;
+                if (!family.userFlows.includes(flowDesc)) {
+                    family.userFlows.push(flowDesc);
+                }
+            }
+        }
+    }
+}

package/dist/esm/knowledge/kg_types.js

@@ -0,0 +1,3 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+export {};

package/dist/esm/knowledge/route_families.js

@@ -30,6 +30,17 @@ export function matchesGlob(filePath, pattern) {
 export function matchesAnyPattern(filePath, patterns) {
     return patterns.some((pattern) => matchesGlob(filePath, pattern));
 }
+function validateApiEndpoint(ep) {
+    if (!ep || typeof ep !== 'object')
+        return null;
+    const obj = ep;
+    if (typeof obj.method !== 'string' || typeof obj.path !== 'string')
+        return null;
+    const result = { method: obj.method, path: obj.path };
+    if (typeof obj.description === 'string')
+        result.description = obj.description;
+    return result;
+}
 function validateFamily(family) {
     if (!family || typeof family !== 'object') {
         return null;
@@ -38,6 +49,10 @@ function validateFamily(family) {
     if (typeof obj.id !== 'string' || !obj.id.trim()) {
         return null;
     }
+    // When testType is 'api', routes may contain API paths like "GET /api/users"
+    const testType = (obj.testType === 'ui' || obj.testType === 'api' || obj.testType === 'both')
+        ? obj.testType
+        : undefined;
     if (!Array.isArray(obj.routes) || obj.routes.length === 0) {
         return null;
     }
@@ -81,6 +96,16 @@ function validateFamily(family) {
             .map((f) => validateFeature(f))
             .filter((f) => f !== null);
     }
+    if (Array.isArray(obj.apiEndpoints)) {
+        const endpoints = obj.apiEndpoints
+            .map((ep) => validateApiEndpoint(ep))
+            .filter((ep) => ep !== null);
+        if (endpoints.length > 0)
+            result.apiEndpoints = endpoints;
+    }
+    if (testType) {
+        result.testType = testType;
+    }
     return result;
 }
 function validateFeature(feature) {
@@ -272,3 +297,67 @@ export function getRoutesForBinding(manifest, binding) {
 export function clearManifestCache() {
     manifestCache.clear();
 }
+/**
+ * Build heuristic route families from changed files when no manifest exists.
+ * Groups files by their top-level directory to create rough family groupings.
+ * Results are lower confidence but allow analysis to proceed without training.
+ */
+export function buildHeuristicFamilies(changedFiles, testsRoot) {
+    const dirGroups = new Map();
+    for (const file of changedFiles) {
+        const normalized = file.replace(/\\/g, '/');
+        const parts = normalized.split('/');
+        // Use the first meaningful directory segment as the family ID
+        // Skip common prefixes like 'src/', 'app/', 'lib/'
+        const skipDirs = new Set(['src', 'app', 'lib', 'packages', 'components']);
+        let familyDir = parts[0] || 'root';
+        if (skipDirs.has(familyDir) && parts.length > 1) {
+            familyDir = parts[1];
+        }
+        // Normalize to a clean family name
+        familyDir = familyDir.replace(/\.[^.]+$/, ''); // strip file extensions for single files
+        if (!dirGroups.has(familyDir)) {
+            dirGroups.set(familyDir, []);
+        }
+        dirGroups.get(familyDir).push(normalized);
+    }
+    const families = [];
+    for (const [dir, files] of dirGroups) {
+        families.push({
+            id: dir,
+            routes: [`/${dir}`],
+            webappPaths: files.map((f) => `${f}*`),
+        });
+    }
+    logger.info(`Built ${families.length} heuristic families from ${changedFiles.length} changed files (no route-families.json found)`);
+    logger.info('Tip: Run `e2e-ai-agents train` to generate a proper route-families manifest for better accuracy.');
+    return {
+        families,
+        source: 'heuristic',
+    };
+}
+/**
+ * Serialize a RouteFamilyManifest to clean JSON, stripping empty optional fields.
+ */
+export function serializeManifest(manifest) {
+    const output = {
+        families: manifest.families.map((f) => {
+            const cleaned = { ...f };
+            const optionalArrays = [
+                'pageObjects', 'components', 'webappPaths', 'serverPaths',
+                'specDirs', 'cypressSpecDirs', 'tags', 'userFlows', 'features', 'apiEndpoints',
+            ];
+            for (const key of optionalArrays) {
+                if (!cleaned[key] || (Array.isArray(cleaned[key]) && cleaned[key].length === 0)) {
+                    delete cleaned[key];
+                }
+            }
+            if (!cleaned.priority)
+                delete cleaned.priority;
+            if (!cleaned.testType)
+                delete cleaned.testType;
+            return cleaned;
+        }),
+    };
+    return JSON.stringify(output, null, 2) + '\n';
+}

package/dist/esm/mcp-server.js

@@ -370,8 +370,7 @@ export class E2EAgentsMCPServer {
             if (!validateGitRef(since)) {
                 return JSON.stringify({ error: 'Invalid git reference format' });
             }
-            // SECURITY: Use -- to separate git options from refs
-            const result = spawnSync('git', ['diff', '--name-only', '--', `${since}..HEAD`], {
+            const result = spawnSync('git', ['diff', '--name-only', `${since}..HEAD`], {
                 cwd: this.repoRoot,
                 encoding: 'utf-8',
                 timeout: 30000,
@@ -439,8 +438,7 @@ export class E2EAgentsMCPServer {
             if (!validateGitRef(since)) {
                 return [];
             }
-            // SECURITY: Use -- separator
-            const result = spawnSync('git', ['diff', '--name-only', '--', `${since}..HEAD`], {
+            const result = spawnSync('git', ['diff', '--name-only', `${since}..HEAD`], {
                 cwd: this.repoRoot,
                 encoding: 'utf-8',
                 timeout: 30000,

package/dist/esm/metrics/prometheus.js

@@ -0,0 +1,149 @@
+// Copyright (c) 2015-present Mattermost, Inc. All Rights Reserved.
+// See LICENSE.txt for license information.
+const DURATION_BUCKETS = [0.1, 0.5, 1, 2, 5, 10, 30, 60, 120, 300];
+export class PrometheusMetrics {
+    constructor() {
+        this.counters = [];
+        this.gauges = [];
+        this.histograms = [];
+    }
+    /**
+     * Record an LLM request.
+     */
+    recordLLMRequest(provider, agent, durationMs, costUSD, tokens) {
+        this.incrementCounter('e2e_agents_llm_requests_total', 'Total LLM requests', { provider, agent });
+        this.incrementCounter('e2e_agents_llm_tokens_total', 'Total tokens consumed', { provider, agent }, tokens);
+        this.incrementCounter('e2e_agents_llm_cost_usd_total', 'Total LLM cost in USD', { provider, agent }, costUSD);
+        this.observeHistogram('e2e_agents_llm_request_duration_seconds', 'LLM request duration', { provider, agent }, durationMs / 1000);
+    }
+    /**
+     * Record a crew workflow run.
+     */
+    recordCrewRun(workflow, families, durationMs, costUSD) {
+        this.incrementCounter('e2e_agents_crew_runs_total', 'Total crew workflow runs', { workflow });
+        this.incrementCounter('e2e_agents_crew_families_processed_total', 'Total families processed', { workflow }, families);
+        this.incrementCounter('e2e_agents_crew_cost_usd_total', 'Total crew cost in USD', { workflow }, costUSD);
+        this.observeHistogram('e2e_agents_crew_duration_seconds', 'Crew workflow duration', { workflow }, durationMs / 1000);
+    }
+    /**
+     * Record a budget check event.
+     */
+    recordBudgetCheck(exceeded, currentUSD, limitUSD) {
+        this.incrementCounter('e2e_agents_budget_checks_total', 'Total budget checks', { exceeded: String(exceeded) });
+        this.setGauge('e2e_agents_budget_used_usd', 'Current budget usage in USD', {}, currentUSD);
+        this.setGauge('e2e_agents_budget_limit_usd', 'Budget limit in USD', {}, limitUSD);
+    }
+    /**
+     * Record a circuit breaker state change.
+     */
+    recordCircuitBreakerState(state) {
+        this.setGauge('e2e_agents_circuit_breaker_state', 'Circuit breaker state (0=closed, 1=open, 2=half-open)', {}, state === 'closed' ? 0 : state === 'open' ? 1 : 2);
+    }
+    /**
+     * Record a cache hit or miss.
+     */
+    recordCacheResult(hit, agent) {
+        this.incrementCounter('e2e_agents_cache_lookups_total', 'Total cache lookups', { result: hit ? 'hit' : 'miss', agent });
+    }
+    /**
+     * Export all metrics in Prometheus text exposition format.
+     */
+    export() {
+        const lines = [];
+        const seenHelp = new Set();
+        // Export counters
+        for (const counter of this.counters) {
+            if (!seenHelp.has(counter.name)) {
+                lines.push(`# HELP ${counter.name} ${counter.help}`);
+                lines.push(`# TYPE ${counter.name} counter`);
+                seenHelp.add(counter.name);
+            }
+            const labelStr = formatLabels(counter.labels);
+            lines.push(`${counter.name}${labelStr} ${counter.value}`);
+        }
+        // Export gauges
+        for (const gauge of this.gauges) {
+            if (!seenHelp.has(gauge.name)) {
+                lines.push(`# HELP ${gauge.name} ${gauge.help}`);
+                lines.push(`# TYPE ${gauge.name} gauge`);
+                seenHelp.add(gauge.name);
+            }
+            const labelStr = formatLabels(gauge.labels);
+            lines.push(`${gauge.name}${labelStr} ${gauge.value}`);
+        }
+        // Export histograms
+        for (const hist of this.histograms) {
+            if (!seenHelp.has(hist.name)) {
+                lines.push(`# HELP ${hist.name} ${hist.help}`);
+                lines.push(`# TYPE ${hist.name} histogram`);
+                seenHelp.add(hist.name);
+            }
+            const labelStr = formatLabels(hist.labels);
+            let cumulative = 0;
+            for (const bucket of DURATION_BUCKETS) {
+                cumulative += hist.buckets.get(bucket) || 0;
+                lines.push(`${hist.name}_bucket${formatLabels({ ...hist.labels, le: String(bucket) })} ${cumulative}`);
+            }
+            lines.push(`${hist.name}_bucket${formatLabels({ ...hist.labels, le: '+Inf' })} ${hist.count}`);
+            lines.push(`${hist.name}_sum${labelStr} ${hist.sum}`);
+            lines.push(`${hist.name}_count${labelStr} ${hist.count}`);
+        }
+        return lines.join('\n') + '\n';
+    }
+    /**
+     * Reset all metrics to zero.
+     */
+    reset() {
+        this.counters = [];
+        this.gauges = [];
+        this.histograms = [];
+    }
+    incrementCounter(name, help, labels, value = 1) {
+        const existing = this.counters.find((c) => c.name === name && labelsMatch(c.labels, labels));
+        if (existing) {
+            existing.value += value;
+        }
+        else {
+            this.counters.push({ name, help, labels, value });
+        }
+    }
+    setGauge(name, help, labels, value) {
+        const existing = this.gauges.find((c) => c.name === name && labelsMatch(c.labels, labels));
+        if (existing) {
+            existing.value = value;
+        }
+        else {
+            this.gauges.push({ name, help, labels, value });
+        }
+    }
+    observeHistogram(name, help, labels, value) {
+        let existing = this.histograms.find((h) => h.name === name && labelsMatch(h.labels, labels));
+        if (!existing) {
+            existing = { name, help, labels, sum: 0, count: 0, buckets: new Map() };
+            this.histograms.push(existing);
+        }
+        existing.sum += value;
+        existing.count++;
+        for (const bucket of DURATION_BUCKETS) {
+            if (value <= bucket) {
+                existing.buckets.set(bucket, (existing.buckets.get(bucket) || 0) + 1);
+            }
+        }
+    }
+}
+function escapeLabel(v) {
+    return v.replace(/\\/g, '\\\\').replace(/"/g, '\\"').replace(/\n/g, '\\n');
+}
+function formatLabels(labels) {
+    const entries = Object.entries(labels);
+    if (entries.length === 0)
+        return '';
+    return `{${entries.map(([k, v]) => `${k}="${escapeLabel(v)}"`).join(',')}}`;
+}
+function labelsMatch(a, b) {
+    const keysA = Object.keys(a);
+    const keysB = Object.keys(b);
+    if (keysA.length !== keysB.length)
+        return false;
+    return keysA.every((k) => a[k] === b[k]);
+}