@dollhousemcp/mcp-server 2.0.0-rc.5 → 2.0.0

package/dist/metrics/collectors/GatekeeperMetricsCollector.js

@@ -0,0 +1,76 @@
+export class GatekeeperMetricsCollector {
+    tracker;
+    name = 'gatekeeper-metrics';
+    description = 'Gatekeeper policy enforcement: allowed/denied/confirmed, policy sources, permission levels.';
+    constructor(tracker) {
+        this.tracker = tracker;
+    }
+    collect() {
+        try {
+            const m = this.tracker.getMetrics();
+            const entries = [
+                {
+                    type: 'counter',
+                    name: 'gatekeeper.decisions_total',
+                    source: 'GatekeeperMetricsTracker',
+                    unit: 'operations',
+                    description: 'Total Gatekeeper policy decisions.',
+                    value: m.totalDecisions,
+                },
+                {
+                    type: 'counter',
+                    name: 'gatekeeper.allowed_total',
+                    source: 'GatekeeperMetricsTracker',
+                    unit: 'operations',
+                    description: 'Operations allowed by Gatekeeper.',
+                    value: m.allowed,
+                },
+                {
+                    type: 'counter',
+                    name: 'gatekeeper.denied_total',
+                    source: 'GatekeeperMetricsTracker',
+                    unit: 'operations',
+                    description: 'Operations denied by Gatekeeper.',
+                    value: m.denied,
+                },
+                {
+                    type: 'counter',
+                    name: 'gatekeeper.confirmations_requested_total',
+                    source: 'GatekeeperMetricsTracker',
+                    unit: 'operations',
+                    description: 'Total operations that requested user confirmation.',
+                    value: m.confirmationsPending,
+                },
+            ];
+            // Per-policy-source gauges
+            for (const [source, count] of m.byPolicySource) {
+                entries.push({
+                    type: 'gauge',
+                    name: 'gatekeeper.by_policy_source',
+                    source: 'GatekeeperMetricsTracker',
+                    unit: 'operations',
+                    description: `Decisions from policy source: ${source}.`,
+                    labels: { policy_source: source },
+                    value: count,
+                });
+            }
+            // Per-permission-level gauges
+            for (const [level, count] of m.byPermissionLevel) {
+                entries.push({
+                    type: 'gauge',
+                    name: 'gatekeeper.by_permission_level',
+                    source: 'GatekeeperMetricsTracker',
+                    unit: 'operations',
+                    description: `Decisions at permission level: ${level}.`,
+                    labels: { permission_level: level },
+                    value: count,
+                });
+            }
+            return entries;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/metrics/collectors/LRUCacheCollector.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Collects hit/miss/eviction and sizing metrics for one or more named LRUCache
+ * instances. Each cache is collected independently; a failure on one does not
+ * prevent the others from being reported.
+ */
+import type { IMetricCollector, MetricEntry } from '../types.js';
+import type { LRUCache } from '../../cache/LRUCache.js';
+export declare class LRUCacheCollector implements IMetricCollector {
+    private readonly caches;
+    readonly name = "lru-cache";
+    readonly description = "Hit rate, eviction counts, size, and memory usage for registered LRU caches";
+    constructor(caches: Array<{
+        name: string;
+        instance: LRUCache<unknown>;
+    }>);
+    collect(): MetricEntry[];
+}
+//# sourceMappingURL=LRUCacheCollector.d.ts.map

package/dist/metrics/collectors/LRUCacheCollector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"LRUCacheCollector.d.ts","sourceRoot":"","sources":["../../../src/metrics/collectors/LRUCacheCollector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,yBAAyB,CAAC;AAIxD,qBAAa,iBAAkB,YAAW,gBAAgB;IAMtD,OAAO,CAAC,QAAQ,CAAC,MAAM;IALzB,QAAQ,CAAC,IAAI,eAAe;IAC5B,QAAQ,CAAC,WAAW,iFAC4D;gBAG7D,MAAM,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,QAAQ,CAAC,OAAO,CAAC,CAAA;KAAE,CAAC;IAG/E,OAAO,IAAI,WAAW,EAAE;CA0FzB"}

package/dist/metrics/collectors/LRUCacheCollector.js

@@ -0,0 +1,95 @@
+/**
+ * Collects hit/miss/eviction and sizing metrics for one or more named LRUCache
+ * instances. Each cache is collected independently; a failure on one does not
+ * prevent the others from being reported.
+ */
+const SOURCE = 'LRUCache';
+export class LRUCacheCollector {
+    caches;
+    name = 'lru-cache';
+    description = 'Hit rate, eviction counts, size, and memory usage for registered LRU caches';
+    constructor(caches) {
+        this.caches = caches;
+    }
+    collect() {
+        const entries = [];
+        for (const { name, instance } of this.caches) {
+            try {
+                const stats = instance.getStats();
+                const labels = { cache: name };
+                entries.push({
+                    type: 'counter',
+                    name: 'cache.lru.hits_total',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Total cache hits',
+                    labels,
+                    value: stats.hitCount,
+                }, {
+                    type: 'counter',
+                    name: 'cache.lru.misses_total',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Total cache misses',
+                    labels,
+                    value: stats.missCount,
+                }, {
+                    type: 'counter',
+                    name: 'cache.lru.evictions_total',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Total entries evicted from cache',
+                    labels,
+                    value: stats.evictionCount,
+                }, {
+                    type: 'gauge',
+                    name: 'cache.lru.hit_rate',
+                    source: SOURCE,
+                    unit: 'ratio',
+                    description: 'Fraction of lookups that resulted in a cache hit',
+                    labels,
+                    value: stats.hitRate,
+                }, {
+                    type: 'gauge',
+                    name: 'cache.lru.size_current',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Current number of entries in cache',
+                    labels,
+                    value: stats.size,
+                }, {
+                    type: 'gauge',
+                    name: 'cache.lru.size_max',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Maximum capacity of the cache',
+                    labels,
+                    value: stats.maxSize,
+                }, {
+                    type: 'gauge',
+                    name: 'cache.lru.memory_used_megabytes',
+                    source: SOURCE,
+                    unit: 'megabytes',
+                    description: 'Estimated memory used by cached entries (MB)',
+                    labels,
+                    value: stats.memoryUsageMB,
+                });
+            }
+            catch (err) {
+                // Record failure as a metric so it's visible in the dashboard.
+                // Individual cache failures should not prevent other caches from reporting.
+                entries.push({
+                    type: 'gauge',
+                    name: 'cache.lru.collection_error',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: `Failed to collect stats: ${err instanceof Error ? err.message : String(err)}`,
+                    labels: { cache: name },
+                    value: 1,
+                });
+            }
+        }
+        return entries;
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/metrics/collectors/OperationMetricsCollector.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Collector for MCP-AQL operation metrics.
+ *
+ * Reads from OperationMetricsTracker and emits counter, histogram,
+ * and gauge metric entries for the MetricsManager pipeline.
+ */
+import type { IMetricCollector, MetricEntry } from '../types.js';
+import { OperationMetricsTracker } from '../OperationMetricsTracker.js';
+export declare class OperationMetricsCollector implements IMetricCollector {
+    private readonly tracker;
+    readonly name = "operation-metrics";
+    readonly description = "MCP-AQL operation counts, durations, and endpoint breakdown.";
+    constructor(tracker: OperationMetricsTracker);
+    collect(): MetricEntry[];
+}
+//# sourceMappingURL=OperationMetricsCollector.d.ts.map

package/dist/metrics/collectors/OperationMetricsCollector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationMetricsCollector.d.ts","sourceRoot":"","sources":["../../../src/metrics/collectors/OperationMetricsCollector.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,EAAE,uBAAuB,EAAE,MAAM,+BAA+B,CAAC;AAExE,qBAAa,yBAA0B,YAAW,gBAAgB;IAIpD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,QAAQ,CAAC,IAAI,uBAAuB;IACpC,QAAQ,CAAC,WAAW,kEAAkE;gBAEzD,OAAO,EAAE,uBAAuB;IAE7D,OAAO,IAAI,WAAW,EAAE;CAyEzB"}

package/dist/metrics/collectors/OperationMetricsCollector.js

@@ -0,0 +1,80 @@
+import { OperationMetricsTracker } from '../OperationMetricsTracker.js';
+export class OperationMetricsCollector {
+    tracker;
+    name = 'operation-metrics';
+    description = 'MCP-AQL operation counts, durations, and endpoint breakdown.';
+    constructor(tracker) {
+        this.tracker = tracker;
+    }
+    collect() {
+        try {
+            const m = this.tracker.getMetrics();
+            const pct = OperationMetricsTracker.percentiles(m.durations);
+            const entries = [
+                {
+                    type: 'counter',
+                    name: 'mcpaql.operations_total',
+                    source: 'OperationMetricsTracker',
+                    unit: 'operations',
+                    description: 'Total MCP-AQL operations executed.',
+                    value: m.totalOps,
+                },
+                {
+                    type: 'counter',
+                    name: 'mcpaql.operations_failed_total',
+                    source: 'OperationMetricsTracker',
+                    unit: 'operations',
+                    description: 'Total MCP-AQL operations that failed.',
+                    value: m.failedOps,
+                },
+                {
+                    type: 'histogram',
+                    name: 'mcpaql.duration',
+                    source: 'OperationMetricsTracker',
+                    unit: 'milliseconds',
+                    description: 'MCP-AQL operation duration distribution.',
+                    value: {
+                        count: pct.count,
+                        sum: pct.sum,
+                        avg: pct.avg,
+                        p50: pct.p50,
+                        p95: pct.p95,
+                        p99: pct.p99,
+                    },
+                },
+            ];
+            // Per-endpoint gauges
+            for (const [endpoint, count] of m.byEndpoint) {
+                entries.push({
+                    type: 'gauge',
+                    name: 'mcpaql.by_endpoint',
+                    source: 'OperationMetricsTracker',
+                    unit: 'operations',
+                    description: `Operations via ${endpoint} endpoint.`,
+                    labels: { endpoint },
+                    value: count,
+                });
+            }
+            // Top 10 operations by count
+            const topOps = [...m.byOperation.entries()]
+                .sort((a, b) => b[1] - a[1])
+                .slice(0, 10);
+            for (const [operation, count] of topOps) {
+                entries.push({
+                    type: 'gauge',
+                    name: 'mcpaql.by_operation',
+                    source: 'OperationMetricsTracker',
+                    unit: 'operations',
+                    description: `Count for operation: ${operation}.`,
+                    labels: { operation },
+                    value: count,
+                });
+            }
+            return entries;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

package/dist/metrics/collectors/OperationalTelemetryCollector.d.ts

@@ -0,0 +1,17 @@
+/**
+ * Collector for OperationalTelemetry enabled/disabled state.
+ *
+ * Emits a single gauge (1 = enabled, 0 = disabled) derived from
+ * `OperationalTelemetry.isEnabled()`, allowing monitoring systems to
+ * alert when telemetry is unexpectedly disabled.
+ */
+import type { IMetricCollector, MetricEntry } from '../types.js';
+import type { OperationalTelemetry } from '../../telemetry/OperationalTelemetry.js';
+export declare class OperationalTelemetryCollector implements IMetricCollector {
+    private readonly telemetry;
+    readonly name = "operational-telemetry";
+    readonly description = "Reports whether OperationalTelemetry is enabled (1) or disabled (0).";
+    constructor(telemetry: OperationalTelemetry);
+    collect(): MetricEntry[];
+}
+//# sourceMappingURL=OperationalTelemetryCollector.d.ts.map

package/dist/metrics/collectors/OperationalTelemetryCollector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"OperationalTelemetryCollector.d.ts","sourceRoot":"","sources":["../../../src/metrics/collectors/OperationalTelemetryCollector.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AACH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,yCAAyC,CAAC;AAEpF,qBAAa,6BAA8B,YAAW,gBAAgB;IAIxD,OAAO,CAAC,QAAQ,CAAC,SAAS;IAHtC,QAAQ,CAAC,IAAI,2BAA2B;IACxC,QAAQ,CAAC,WAAW,0EAA0E;gBAEjE,SAAS,EAAE,oBAAoB;IAE5D,OAAO,IAAI,WAAW,EAAE;CAgBzB"}

package/dist/metrics/collectors/OperationalTelemetryCollector.js

@@ -0,0 +1,26 @@
+export class OperationalTelemetryCollector {
+    telemetry;
+    name = 'operational-telemetry';
+    description = 'Reports whether OperationalTelemetry is enabled (1) or disabled (0).';
+    constructor(telemetry) {
+        this.telemetry = telemetry;
+    }
+    collect() {
+        try {
+            return [
+                {
+                    type: 'gauge',
+                    name: 'telemetry.operational.enabled',
+                    source: 'OperationalTelemetry',
+                    unit: 'none',
+                    description: 'Operational telemetry enabled state: 1 = enabled, 0 = disabled.',
+                    value: this.telemetry.isEnabled() ? 1 : 0,
+                },
+            ];
+        }
+        catch {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoiT3BlcmF0aW9uYWxUZWxlbWV0cnlDb2xsZWN0b3IuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi9zcmMvbWV0cmljcy9jb2xsZWN0b3JzL09wZXJhdGlvbmFsVGVsZW1ldHJ5Q29sbGVjdG9yLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQVVBLE1BQU0sT0FBTyw2QkFBNkI7SUFJWDtJQUhwQixJQUFJLEdBQUcsdUJBQXVCLENBQUM7SUFDL0IsV0FBVyxHQUFHLHNFQUFzRSxDQUFDO0lBRTlGLFlBQTZCLFNBQStCO1FBQS9CLGNBQVMsR0FBVCxTQUFTLENBQXNCO0lBQUcsQ0FBQztJQUVoRSxPQUFPO1FBQ0wsSUFBSSxDQUFDO1lBQ0gsT0FBTztnQkFDTDtvQkFDRSxJQUFJLEVBQUUsT0FBZ0I7b0JBQ3RCLElBQUksRUFBRSwrQkFBK0I7b0JBQ3JDLE1BQU0sRUFBRSxzQkFBc0I7b0JBQzlCLElBQUksRUFBRSxNQUFlO29CQUNyQixXQUFXLEVBQUUsaUVBQWlFO29CQUM5RSxLQUFLLEVBQUUsSUFBSSxDQUFDLFNBQVMsQ0FBQyxTQUFTLEVBQUUsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDLENBQUMsQ0FBQyxDQUFDO2lCQUMxQzthQUNGLENBQUM7UUFDSixDQUFDO1FBQUMsTUFBTSxDQUFDO1lBQ1AsT0FBTyxFQUFFLENBQUM7UUFDWixDQUFDO0lBQ0gsQ0FBQztDQUNGIiwic291cmNlc0NvbnRlbnQiOlsiLyoqXG4gKiBDb2xsZWN0b3IgZm9yIE9wZXJhdGlvbmFsVGVsZW1ldHJ5IGVuYWJsZWQvZGlzYWJsZWQgc3RhdGUuXG4gKlxuICogRW1pdHMgYSBzaW5nbGUgZ2F1Z2UgKDEgPSBlbmFibGVkLCAwID0gZGlzYWJsZWQpIGRlcml2ZWQgZnJvbVxuICogYE9wZXJhdGlvbmFsVGVsZW1ldHJ5LmlzRW5hYmxlZCgpYCwgYWxsb3dpbmcgbW9uaXRvcmluZyBzeXN0ZW1zIHRvXG4gKiBhbGVydCB3aGVuIHRlbGVtZXRyeSBpcyB1bmV4cGVjdGVkbHkgZGlzYWJsZWQuXG4gKi9cbmltcG9ydCB0eXBlIHsgSU1ldHJpY0NvbGxlY3RvciwgTWV0cmljRW50cnkgfSBmcm9tICcuLi90eXBlcy5qcyc7XG5pbXBvcnQgdHlwZSB7IE9wZXJhdGlvbmFsVGVsZW1ldHJ5IH0gZnJvbSAnLi4vLi4vdGVsZW1ldHJ5L09wZXJhdGlvbmFsVGVsZW1ldHJ5LmpzJztcblxuZXhwb3J0IGNsYXNzIE9wZXJhdGlvbmFsVGVsZW1ldHJ5Q29sbGVjdG9yIGltcGxlbWVudHMgSU1ldHJpY0NvbGxlY3RvciB7XG4gIHJlYWRvbmx5IG5hbWUgPSAnb3BlcmF0aW9uYWwtdGVsZW1ldHJ5JztcbiAgcmVhZG9ubHkgZGVzY3JpcHRpb24gPSAnUmVwb3J0cyB3aGV0aGVyIE9wZXJhdGlvbmFsVGVsZW1ldHJ5IGlzIGVuYWJsZWQgKDEpIG9yIGRpc2FibGVkICgwKS4nO1xuXG4gIGNvbnN0cnVjdG9yKHByaXZhdGUgcmVhZG9ubHkgdGVsZW1ldHJ5OiBPcGVyYXRpb25hbFRlbGVtZXRyeSkge31cblxuICBjb2xsZWN0KCk6IE1ldHJpY0VudHJ5W10ge1xuICAgIHRyeSB7XG4gICAgICByZXR1cm4gW1xuICAgICAgICB7XG4gICAgICAgICAgdHlwZTogJ2dhdWdlJyBhcyBjb25zdCxcbiAgICAgICAgICBuYW1lOiAndGVsZW1ldHJ5Lm9wZXJhdGlvbmFsLmVuYWJsZWQnLFxuICAgICAgICAgIHNvdXJjZTogJ09wZXJhdGlvbmFsVGVsZW1ldHJ5JyxcbiAgICAgICAgICB1bml0OiAnbm9uZScgYXMgY29uc3QsXG4gICAgICAgICAgZGVzY3JpcHRpb246ICdPcGVyYXRpb25hbCB0ZWxlbWV0cnkgZW5hYmxlZCBzdGF0ZTogMSA9IGVuYWJsZWQsIDAgPSBkaXNhYmxlZC4nLFxuICAgICAgICAgIHZhbHVlOiB0aGlzLnRlbGVtZXRyeS5pc0VuYWJsZWQoKSA/IDEgOiAwLFxuICAgICAgICB9LFxuICAgICAgXTtcbiAgICB9IGNhdGNoIHtcbiAgICAgIHJldHVybiBbXTtcbiAgICB9XG4gIH1cbn1cbiJdfQ==

package/dist/metrics/collectors/PerformanceMonitorCollector.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Collects search-performance and system-resource metrics from a PerformanceMonitor
+ * instance. Returns an empty array (never throws) when the source is unavailable.
+ */
+import type { IMetricCollector, MetricEntry } from '../types.js';
+import type { PerformanceMonitor } from '../../utils/PerformanceMonitor.js';
+export declare class PerformanceMonitorCollector implements IMetricCollector {
+    private readonly monitor;
+    readonly name = "performance-monitor";
+    readonly description = "Search performance timings, cache hit rate, and system memory/CPU from PerformanceMonitor";
+    constructor(monitor: PerformanceMonitor);
+    collect(): MetricEntry[];
+}
+//# sourceMappingURL=PerformanceMonitorCollector.d.ts.map

package/dist/metrics/collectors/PerformanceMonitorCollector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PerformanceMonitorCollector.d.ts","sourceRoot":"","sources":["../../../src/metrics/collectors/PerformanceMonitorCollector.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AACjE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,mCAAmC,CAAC;AAI5E,qBAAa,2BAA4B,YAAW,gBAAgB;IAKtD,OAAO,CAAC,QAAQ,CAAC,OAAO;IAJpC,QAAQ,CAAC,IAAI,yBAAyB;IACtC,QAAQ,CAAC,WAAW,+FAC0E;gBAEjE,OAAO,EAAE,kBAAkB;IAExD,OAAO,IAAI,WAAW,EAAE;CAiIzB"}

package/dist/metrics/collectors/PerformanceMonitorCollector.js

@@ -0,0 +1,141 @@
+/**
+ * Collects search-performance and system-resource metrics from a PerformanceMonitor
+ * instance. Returns an empty array (never throws) when the source is unavailable.
+ */
+const SOURCE = 'PerformanceMonitor';
+export class PerformanceMonitorCollector {
+    monitor;
+    name = 'performance-monitor';
+    description = 'Search performance timings, cache hit rate, and system memory/CPU from PerformanceMonitor';
+    constructor(monitor) {
+        this.monitor = monitor;
+    }
+    collect() {
+        try {
+            const metrics = this.monitor.getMetrics();
+            const searchStats = this.monitor.getSearchStats();
+            const memStats = this.monitor.getMemoryStats();
+            const searchTimes = metrics.searchTimes ?? [];
+            const histCount = searchTimes.length;
+            const histSum = searchTimes.reduce((s, v) => s + v, 0);
+            const entries = [
+                {
+                    type: 'counter',
+                    name: 'performance.search.searches_total',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Total number of searches performed',
+                    value: searchStats.totalSearches,
+                },
+                {
+                    type: 'histogram',
+                    name: 'performance.search.duration',
+                    source: SOURCE,
+                    unit: 'milliseconds',
+                    description: 'Distribution of search durations',
+                    value: {
+                        count: histCount,
+                        sum: histSum,
+                        avg: searchStats.averageTime,
+                        p50: searchStats.medianTime,
+                        p95: searchStats.p95Time,
+                        p99: searchStats.p99Time,
+                    },
+                },
+                {
+                    type: 'counter',
+                    name: 'performance.search.slow_query_count',
+                    source: SOURCE,
+                    unit: 'count',
+                    description: 'Number of searches that exceeded the slow-query threshold',
+                    value: searchStats.slowQueries,
+                },
+                {
+                    type: 'gauge',
+                    name: 'performance.search.cache_hit_rate',
+                    source: SOURCE,
+                    unit: 'ratio',
+                    description: 'Fraction of searches served from cache',
+                    value: searchStats.cacheHitRate,
+                },
+                {
+                    type: 'gauge',
+                    name: 'system.memory.heap_used_bytes',
+                    source: SOURCE,
+                    unit: 'bytes',
+                    description: 'V8 heap used (bytes)',
+                    value: memStats.currentUsage.heapUsed,
+                },
+                {
+                    type: 'gauge',
+                    name: 'system.memory.heap_total_bytes',
+                    source: SOURCE,
+                    unit: 'bytes',
+                    description: 'V8 heap total (bytes)',
+                    value: memStats.currentUsage.heapTotal,
+                },
+                {
+                    type: 'gauge',
+                    name: 'system.memory.rss_bytes',
+                    source: SOURCE,
+                    unit: 'bytes',
+                    description: 'Process resident set size (bytes)',
+                    value: memStats.currentUsage.rss,
+                },
+                {
+                    type: 'gauge',
+                    name: 'system.memory.external_bytes',
+                    source: SOURCE,
+                    unit: 'bytes',
+                    description: 'V8 external memory (bytes)',
+                    value: memStats.currentUsage.external,
+                },
+                {
+                    type: 'gauge',
+                    name: 'system.memory.growth_rate',
+                    source: SOURCE,
+                    unit: 'megabytes',
+                    description: 'Heap growth rate (MB/s)',
+                    value: memStats.growthRate,
+                },
+                {
+                    type: 'counter',
+                    name: 'system.cpu.usage_seconds',
+                    source: SOURCE,
+                    unit: 'seconds',
+                    description: 'CPU time consumed by the process (seconds)',
+                    value: metrics.systemStats.cpuUsage,
+                },
+                {
+                    type: 'counter',
+                    name: 'system.uptime_seconds',
+                    source: SOURCE,
+                    unit: 'seconds',
+                    description: 'Process uptime (seconds)',
+                    value: metrics.systemStats.uptime,
+                },
+                {
+                    type: 'gauge',
+                    name: 'system.memory.free_bytes',
+                    source: SOURCE,
+                    unit: 'bytes',
+                    description: 'System free memory (bytes)',
+                    value: metrics.systemStats.freeMemory,
+                },
+                {
+                    type: 'gauge',
+                    name: 'system.memory.total_bytes',
+                    source: SOURCE,
+                    unit: 'bytes',
+                    description: 'System total memory (bytes)',
+                    value: metrics.systemStats.totalMemory,
+                },
+            ];
+            return entries;
+        }
+        catch {
+            return [];
+        }
+    }
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"PerformanceMonitorCollector.js","sourceRoot":"","sources":["../../../src/metrics/collectors/PerformanceMonitorCollector.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Collects search-performance and system-resource metrics from a PerformanceMonitor\n * instance. Returns an empty array (never throws) when the source is unavailable.\n */\n\nimport type { IMetricCollector, MetricEntry } from '../types.js';\nimport type { PerformanceMonitor } from '../../utils/PerformanceMonitor.js';\n\nconst SOURCE = 'PerformanceMonitor' as const;\n\nexport class PerformanceMonitorCollector implements IMetricCollector {\n  readonly name = 'performance-monitor';\n  readonly description =\n    'Search performance timings, cache hit rate, and system memory/CPU from PerformanceMonitor';\n\n  constructor(private readonly monitor: PerformanceMonitor) {}\n\n  collect(): MetricEntry[] {\n    try {\n      const metrics = this.monitor.getMetrics();\n      const searchStats = this.monitor.getSearchStats();\n      const memStats = this.monitor.getMemoryStats();\n\n      const searchTimes: number[] = metrics.searchTimes ?? [];\n      const histCount = searchTimes.length;\n      const histSum = searchTimes.reduce((s, v) => s + v, 0);\n\n      const entries: MetricEntry[] = [\n        {\n          type: 'counter' as const,\n          name: 'performance.search.searches_total',\n          source: SOURCE,\n          unit: 'count' as const,\n          description: 'Total number of searches performed',\n          value: searchStats.totalSearches,\n        },\n        {\n          type: 'histogram' as const,\n          name: 'performance.search.duration',\n          source: SOURCE,\n          unit: 'milliseconds' as const,\n          description: 'Distribution of search durations',\n          value: {\n            count: histCount,\n            sum: histSum,\n            avg: searchStats.averageTime,\n            p50: searchStats.medianTime,\n            p95: searchStats.p95Time,\n            p99: searchStats.p99Time,\n          },\n        },\n        {\n          type: 'counter' as const,\n          name: 'performance.search.slow_query_count',\n          source: SOURCE,\n          unit: 'count' as const,\n          description: 'Number of searches that exceeded the slow-query threshold',\n          value: searchStats.slowQueries,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'performance.search.cache_hit_rate',\n          source: SOURCE,\n          unit: 'ratio' as const,\n          description: 'Fraction of searches served from cache',\n          value: searchStats.cacheHitRate,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'system.memory.heap_used_bytes',\n          source: SOURCE,\n          unit: 'bytes' as const,\n          description: 'V8 heap used (bytes)',\n          value: memStats.currentUsage.heapUsed,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'system.memory.heap_total_bytes',\n          source: SOURCE,\n          unit: 'bytes' as const,\n          description: 'V8 heap total (bytes)',\n          value: memStats.currentUsage.heapTotal,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'system.memory.rss_bytes',\n          source: SOURCE,\n          unit: 'bytes' as const,\n          description: 'Process resident set size (bytes)',\n          value: memStats.currentUsage.rss,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'system.memory.external_bytes',\n          source: SOURCE,\n          unit: 'bytes' as const,\n          description: 'V8 external memory (bytes)',\n          value: memStats.currentUsage.external,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'system.memory.growth_rate',\n          source: SOURCE,\n          unit: 'megabytes' as const,\n          description: 'Heap growth rate (MB/s)',\n          value: memStats.growthRate,\n        },\n        {\n          type: 'counter' as const,\n          name: 'system.cpu.usage_seconds',\n          source: SOURCE,\n          unit: 'seconds' as const,\n          description: 'CPU time consumed by the process (seconds)',\n          value: metrics.systemStats.cpuUsage,\n        },\n        {\n          type: 'counter' as const,\n          name: 'system.uptime_seconds',\n          source: SOURCE,\n          unit: 'seconds' as const,\n          description: 'Process uptime (seconds)',\n          value: metrics.systemStats.uptime,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'system.memory.free_bytes',\n          source: SOURCE,\n          unit: 'bytes' as const,\n          description: 'System free memory (bytes)',\n          value: metrics.systemStats.freeMemory,\n        },\n        {\n          type: 'gauge' as const,\n          name: 'system.memory.total_bytes',\n          source: SOURCE,\n          unit: 'bytes' as const,\n          description: 'System total memory (bytes)',\n          value: metrics.systemStats.totalMemory,\n        },\n      ];\n\n      return entries;\n    } catch {\n      return [];\n    }\n  }\n}\n"]}

package/dist/metrics/collectors/SecurityMonitorCollector.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Collects aggregate security-event counts from SecurityMonitor, broken down
+ * by severity and event type. Accepts an injectable report function so the
+ * collector can be tested without a live SecurityMonitor singleton.
+ */
+import type { IMetricCollector, MetricEntry } from '../types.js';
+interface SecurityReport {
+    totalEvents: number;
+    eventsBySeverity: Record<string, number>;
+    eventsByType: Record<string, number>;
+    recentCriticalEvents: unknown[];
+}
+export declare class SecurityMonitorCollector implements IMetricCollector {
+    readonly name = "security-monitor";
+    readonly description = "Total security events and per-severity/per-type breakdowns from SecurityMonitor";
+    private readonly reportFn;
+    constructor(reportFn?: () => SecurityReport);
+    collect(): MetricEntry[];
+}
+export {};
+//# sourceMappingURL=SecurityMonitorCollector.d.ts.map

package/dist/metrics/collectors/SecurityMonitorCollector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SecurityMonitorCollector.d.ts","sourceRoot":"","sources":["../../../src/metrics/collectors/SecurityMonitorCollector.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,KAAK,EAAE,gBAAgB,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAKjE,UAAU,cAAc;IACtB,WAAW,EAAE,MAAM,CAAC;IACpB,gBAAgB,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACzC,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;IACrC,oBAAoB,EAAE,OAAO,EAAE,CAAC;CACjC;AAED,qBAAa,wBAAyB,YAAW,gBAAgB;IAC/D,QAAQ,CAAC,IAAI,sBAAsB;IACnC,QAAQ,CAAC,WAAW,qFACgE;IAEpF,OAAO,CAAC,QAAQ,CAAC,QAAQ,CAAuB;gBAEpC,QAAQ,CAAC,EAAE,MAAM,cAAc;IAI3C,OAAO,IAAI,WAAW,EAAE;CA2CzB"}