observability-toolkit 2.0.0 → 2.1.0

package/dist/lib/core/constants.test.js

@@ -0,0 +1,833 @@
+/**
+ * Unit tests for constants.ts
+ */
+import { describe, it, before, after, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import * as fs from 'fs';
+import * as os from 'os';
+import { join } from 'path';
+import * as constants from './constants.js';
+import * as units from './units.js';
+import { getSharedTempDir, clearTempDir, removeSharedTempDir } from '../../test-helpers/file-utils.js';
+import { COUNT_EIGHT, COUNT_FIVE, COUNT_FOUR, COUNT_HUNDRED, COUNT_NINETY, COUNT_SEVEN, COUNT_TEN, COUNT_THREE, COUNT_THIRTY, COUNT_TWENTY_FIVE, COUNT_TWO, } from '../../test-helpers/test-constants.js';
+const EXPECTED_CONTEXT_WARNING_THRESHOLD = COUNT_SEVEN / COUNT_TEN; // .7
+const EXPECTED_CONTEXT_CRITICAL_THRESHOLD = COUNT_EIGHT / COUNT_TEN; // .8
+const EXPECTED_CONTEXT_EXCEEDED_THRESHOLD = units.PERCENTILE.P95 / units.PERCENT_MULTIPLIER; //>95
+const EXPECTED_TOKENS_PER_CHAR = COUNT_TWENTY_FIVE / COUNT_HUNDRED; // .25
+describe('Constants', () => {
+    describe('TELEMETRY_DIR', () => {
+        it('should be a string', () => {
+            assert.strictEqual(typeof constants.TELEMETRY_DIR, 'string');
+        });
+        it('should default to .otel under cwd when TELEMETRY_DIR env var not set', () => {
+            if (!process.env.TELEMETRY_DIR) {
+                const expected = join(process.cwd(), '.otel');
+                assert.strictEqual(constants.TELEMETRY_DIR, expected);
+            }
+        });
+        it('should contain expected path segments', () => {
+            assert(constants.TELEMETRY_DIR.includes('telemetry') ||
+                constants.TELEMETRY_DIR.includes('.claude'));
+        });
+    });
+    describe('CIRCUIT_BREAKER', () => {
+        it('should be an object', () => {
+            assert.strictEqual(typeof constants.CIRCUIT_BREAKER, 'object');
+            assert(constants.CIRCUIT_BREAKER !== null);
+        });
+        it('should have MAX_FAILURES property', () => {
+            assert('MAX_FAILURES' in constants.CIRCUIT_BREAKER);
+        });
+        it('should have RESET_MS property', () => {
+            assert('RESET_MS' in constants.CIRCUIT_BREAKER);
+        });
+        it('MAX_FAILURES should be a number', () => {
+            assert.strictEqual(typeof constants.CIRCUIT_BREAKER.MAX_FAILURES, 'number');
+        });
+        it('RESET_MS should be a number', () => {
+            assert.strictEqual(typeof constants.CIRCUIT_BREAKER.RESET_MS, 'number');
+        });
+        it('MAX_FAILURES should default to 3', () => {
+            if (!process.env.CIRCUIT_BREAKER_MAX_FAILURES) {
+                assert.strictEqual(constants.CIRCUIT_BREAKER.MAX_FAILURES, COUNT_THREE);
+            }
+        });
+        it('RESET_MS should default to 60_000', () => {
+            if (!process.env.CIRCUIT_BREAKER_RESET_MS) {
+                assert.strictEqual(constants.CIRCUIT_BREAKER.RESET_MS, units.TIME_MS.MINUTE);
+            }
+        });
+        it('MAX_FAILURES should respect CIRCUIT_BREAKER_MAX_FAILURES env var', () => {
+            if (process.env.CIRCUIT_BREAKER_MAX_FAILURES) {
+                const expected = parseInt(process.env.CIRCUIT_BREAKER_MAX_FAILURES, 10);
+                assert.strictEqual(constants.CIRCUIT_BREAKER.MAX_FAILURES, expected);
+            }
+        });
+        it('RESET_MS should respect CIRCUIT_BREAKER_RESET_MS env var', () => {
+            if (process.env.CIRCUIT_BREAKER_RESET_MS) {
+                const expected = parseInt(process.env.CIRCUIT_BREAKER_RESET_MS, 10);
+                assert.strictEqual(constants.CIRCUIT_BREAKER.RESET_MS, expected);
+            }
+        });
+        it('should be typed as readonly via as const', () => {
+            // Note: `as const` provides TypeScript compile-time readonly,
+            // but doesn't freeze the object at runtime
+            assert.ok(typeof constants.CIRCUIT_BREAKER === 'object');
+            assert.ok('MAX_FAILURES' in constants.CIRCUIT_BREAKER);
+            assert.ok('RESET_MS' in constants.CIRCUIT_BREAKER);
+            // Skip runtime freeze test since `as const` is compile-time only
+        });
+    });
+    describe('CONTEXT_WINDOW_SIZE', () => {
+        it('should be a number', () => {
+            assert.strictEqual(typeof constants.CONTEXT_WINDOW_SIZE, 'number');
+        });
+        it('should equal 200000', () => {
+            assert.strictEqual(constants.CONTEXT_WINDOW_SIZE, constants.OPENAI_WINDOW_SIZE_LARGE);
+        });
+    });
+    describe('MODEL_CONTEXT_WINDOWS', () => {
+        it('should be a non-empty object', () => {
+            assert.strictEqual(typeof constants.MODEL_CONTEXT_WINDOWS, 'object');
+            assert(Object.keys(constants.MODEL_CONTEXT_WINDOWS).length > 0);
+        });
+        it('should have entries for all MODEL_PRICING models', () => {
+            for (const model of Object.keys(constants.MODEL_PRICING)) {
+                assert(constants.MODEL_CONTEXT_WINDOWS[model] !== undefined, `Missing context window for model: ${model}`);
+            }
+        });
+        it('should have pricing entries for all MODEL_CONTEXT_WINDOWS models', () => {
+            for (const model of Object.keys(constants.MODEL_CONTEXT_WINDOWS)) {
+                assert(constants.MODEL_PRICING[model] !== undefined, `Missing pricing for model: ${model}`);
+            }
+        });
+        it('should have positive integer values', () => {
+            for (const [model, size] of Object.entries(constants.MODEL_CONTEXT_WINDOWS)) {
+                assert(Number.isInteger(size) && size > 0, `Invalid window for ${model}: ${size}`);
+            }
+        });
+        it('should have known values for key models', () => {
+            assert.strictEqual(constants.MODEL_CONTEXT_WINDOWS['claude-opus-4-6'], constants.CONTEXT_WINDOW_SIZE);
+            assert.strictEqual(constants.MODEL_CONTEXT_WINDOWS['gpt-4o'], constants.OPENAI_WINDOW_SIZE);
+            assert.strictEqual(constants.MODEL_CONTEXT_WINDOWS['gemini-2.0-flash'], constants.GEMINI_WINDOW_SIZE);
+        });
+    });
+    describe('getContextWindowSize', () => {
+        it('should return exact match', () => {
+            assert.strictEqual(constants.getContextWindowSize('claude-opus-4-6'), constants.CONTEXT_WINDOW_SIZE);
+        });
+        it('should return prefix match for versioned model', () => {
+            assert.strictEqual(constants.getContextWindowSize('claude-opus-4-6-20260301'), constants.CONTEXT_WINDOW_SIZE);
+        });
+        it('should return fallback for unknown model', () => {
+            assert.strictEqual(constants.getContextWindowSize('unknown-model-xyz'), constants.CONTEXT_WINDOW_SIZE);
+        });
+        it('should return fallback for empty string', () => {
+            assert.strictEqual(constants.getContextWindowSize(''), constants.CONTEXT_WINDOW_SIZE);
+        });
+    });
+    describe('CONTEXT_ALERT_THRESHOLDS', () => {
+        it('should have warning < critical < exceeded', () => {
+            assert(constants.CONTEXT_ALERT_THRESHOLDS.WARNING < constants.CONTEXT_ALERT_THRESHOLDS.CRITICAL);
+            assert(constants.CONTEXT_ALERT_THRESHOLDS.CRITICAL < constants.CONTEXT_ALERT_THRESHOLDS.EXCEEDED);
+        });
+        it('should have known values', () => {
+            assert.strictEqual(constants.CONTEXT_ALERT_THRESHOLDS.WARNING, EXPECTED_CONTEXT_WARNING_THRESHOLD);
+            assert.strictEqual(constants.CONTEXT_ALERT_THRESHOLDS.CRITICAL, EXPECTED_CONTEXT_CRITICAL_THRESHOLD);
+            assert.strictEqual(constants.CONTEXT_ALERT_THRESHOLDS.EXCEEDED, EXPECTED_CONTEXT_EXCEEDED_THRESHOLD);
+        });
+    });
+    describe('TOKENS_PER_CHAR', () => {
+        it('should be a number', () => {
+            assert.strictEqual(typeof constants.TOKENS_PER_CHAR, 'number');
+        });
+        it('should equal 0.25', () => {
+            assert.strictEqual(constants.TOKENS_PER_CHAR, EXPECTED_TOKENS_PER_CHAR);
+        });
+    });
+    describe('MODEL_PRICING', () => {
+        it('should be an object', () => {
+            assert.strictEqual(typeof constants.MODEL_PRICING, 'object');
+            assert(constants.MODEL_PRICING !== null);
+        });
+        it('should have pricing entries', () => {
+            const keys = Object.keys(constants.MODEL_PRICING);
+            assert(keys.length > 0);
+        });
+        it('should contain claude-opus-4-5-20251101', () => {
+            assert('claude-opus-4-5-20251101' in constants.MODEL_PRICING);
+        });
+        it('should contain claude-sonnet-4-20250514', () => {
+            assert('claude-sonnet-4-20250514' in constants.MODEL_PRICING);
+        });
+        it('should contain claude-3-5-haiku-20241022', () => {
+            assert('claude-3-5-haiku-20241022' in constants.MODEL_PRICING);
+        });
+        it('each pricing entry should have input and output properties', () => {
+            Object.values(constants.MODEL_PRICING).forEach(pricing => {
+                assert.strictEqual(typeof pricing.input, 'number');
+                assert.strictEqual(typeof pricing.output, 'number');
+            });
+        });
+        it('Opus should have higher pricing than Sonnet', () => {
+            const opus = constants.MODEL_PRICING['claude-opus-4-5-20251101'];
+            const sonnet = constants.MODEL_PRICING['claude-sonnet-4-20250514'];
+            assert(opus.input > sonnet.input);
+            assert(opus.output > sonnet.output);
+        });
+        it('Sonnet should have higher pricing than Haiku', () => {
+            const sonnet = constants.MODEL_PRICING['claude-sonnet-4-20250514'];
+            const haiku = constants.MODEL_PRICING['claude-3-5-haiku-20241022'];
+            assert(sonnet.input > haiku.input);
+            assert(sonnet.output > haiku.output);
+        });
+        it('output pricing should be >= input pricing for all models', () => {
+            Object.values(constants.MODEL_PRICING).forEach(pricing => {
+                assert(pricing.output >= pricing.input, `Expected output (${pricing.output}) >= input (${pricing.input})`);
+            });
+        });
+        // Multi-provider support tests
+        describe('OpenAI models', () => {
+            it('should contain gpt-4o', () => {
+                assert('gpt-4o' in constants.MODEL_PRICING);
+            });
+            it('should contain gpt-4o-mini', () => {
+                assert('gpt-4o-mini' in constants.MODEL_PRICING);
+            });
+            it('should contain gpt-4-turbo', () => {
+                assert('gpt-4-turbo' in constants.MODEL_PRICING);
+            });
+            it('should contain gpt-3.5-turbo', () => {
+                assert('gpt-3.5-turbo' in constants.MODEL_PRICING);
+            });
+            it('should contain o1 reasoning model', () => {
+                assert('o1' in constants.MODEL_PRICING);
+            });
+            it('should contain o1-mini', () => {
+                assert('o1-mini' in constants.MODEL_PRICING);
+            });
+        });
+        describe('Google Gemini models', () => {
+            it('should contain gemini-1.5-pro', () => {
+                assert('gemini-1.5-pro' in constants.MODEL_PRICING);
+            });
+            it('should contain gemini-1.5-flash', () => {
+                assert('gemini-1.5-flash' in constants.MODEL_PRICING);
+            });
+            it('should contain gemini-2.0-flash', () => {
+                assert('gemini-2.0-flash' in constants.MODEL_PRICING);
+            });
+            it('Gemini Pro should have higher pricing than Flash', () => {
+                const pro = constants.MODEL_PRICING['gemini-1.5-pro'];
+                const flash = constants.MODEL_PRICING['gemini-1.5-flash'];
+                assert(pro.input > flash.input);
+                assert(pro.output > flash.output);
+            });
+        });
+        describe('Mistral AI models', () => {
+            it('should contain mistral-large', () => {
+                assert('mistral-large' in constants.MODEL_PRICING);
+            });
+            it('should contain mistral-small', () => {
+                assert('mistral-small' in constants.MODEL_PRICING);
+            });
+            it('should contain codestral', () => {
+                assert('codestral' in constants.MODEL_PRICING);
+            });
+            it('Mistral large should have higher pricing than small', () => {
+                const large = constants.MODEL_PRICING['mistral-large'];
+                const small = constants.MODEL_PRICING['mistral-small'];
+                assert(large.input > small.input);
+                assert(large.output > small.output);
+            });
+        });
+        describe('Cohere models', () => {
+            it('should contain command-r-plus', () => {
+                assert('command-r-plus' in constants.MODEL_PRICING);
+            });
+            it('should contain command-r', () => {
+                assert('command-r' in constants.MODEL_PRICING);
+            });
+            it('Command R Plus should have higher pricing than Command R', () => {
+                const plus = constants.MODEL_PRICING['command-r-plus'];
+                const r = constants.MODEL_PRICING['command-r'];
+                assert(plus.input > r.input);
+                assert(plus.output > r.output);
+            });
+        });
+        describe('Groq models', () => {
+            it('should contain llama-3.3-70b', () => {
+                assert('llama-3.3-70b' in constants.MODEL_PRICING);
+            });
+            it('should contain llama-3.1-8b', () => {
+                assert('llama-3.1-8b' in constants.MODEL_PRICING);
+            });
+            it('Larger llama model should have higher pricing', () => {
+                const large = constants.MODEL_PRICING['llama-3.3-70b'];
+                const small = constants.MODEL_PRICING['llama-3.1-8b'];
+                assert(large.input > small.input);
+                assert(large.output > small.output);
+            });
+        });
+        describe('Perplexity models', () => {
+            it('should contain sonar-pro', () => {
+                assert('sonar-pro' in constants.MODEL_PRICING);
+            });
+            it('should contain sonar', () => {
+                assert('sonar' in constants.MODEL_PRICING);
+            });
+        });
+        describe('model count', () => {
+            it('should have at least 30 models defined', () => {
+                const modelCount = Object.keys(constants.MODEL_PRICING).length;
+                assert(modelCount >= COUNT_THIRTY, `Expected at least 30 models, got ${modelCount}`);
+            });
+        });
+    });
+    describe('MODEL_PRICING_METADATA', () => {
+        it('should have lastUpdated as valid ISO date', () => {
+            const date = new Date(constants.MODEL_PRICING_METADATA.lastUpdated);
+            assert.ok(!isNaN(date.getTime()), 'lastUpdated should be a valid date');
+        });
+        it('should have staleThresholdDays as positive number', () => {
+            assert.ok(constants.MODEL_PRICING_METADATA.staleThresholdDays > 0);
+        });
+        it('should have staleThresholdDays default to 90', () => {
+            assert.strictEqual(constants.MODEL_PRICING_METADATA.staleThresholdDays, COUNT_NINETY);
+        });
+        it('should have sources object with provider URLs', () => {
+            const sources = constants.MODEL_PRICING_METADATA.sources;
+            assert.ok(typeof sources === 'object');
+            assert.ok(sources.anthropic.includes('anthropic.com'));
+            assert.ok(sources.openai.includes('openai.com'));
+            assert.ok(sources.google.includes('google'));
+            assert.ok(sources.mistral.includes('mistral.ai'));
+            assert.ok(sources.cohere.includes('cohere.com'));
+        });
+    });
+    describe('checkPricingStaleness', () => {
+        it('should return isStale and daysSinceUpdate', () => {
+            const result = constants.checkPricingStaleness();
+            assert.ok('isStale' in result);
+            assert.ok('daysSinceUpdate' in result);
+            assert.strictEqual(typeof result.isStale, 'boolean');
+            assert.strictEqual(typeof result.daysSinceUpdate, 'number');
+        });
+        it('should calculate daysSinceUpdate correctly', () => {
+            const result = constants.checkPricingStaleness();
+            const lastUpdate = new Date(constants.MODEL_PRICING_METADATA.lastUpdated);
+            const now = new Date();
+            const expectedDays = Math.floor((now.getTime() - lastUpdate.getTime())
+                / (units.TIME_MS.SECOND
+                    * units.SECONDS.MINUTE
+                    * units.MINUTES_PER_HOUR
+                    * units.HOURS_PER_DAY));
+            assert.strictEqual(result.daysSinceUpdate, expectedDays);
+        });
+        it('should return isStale: true when data is >90 days old', () => {
+            // Note: This test documents expected behavior
+            // When data is fresh (<90 days), isStale should be false
+            // When data is old (>90 days), isStale should be true
+            const result = constants.checkPricingStaleness();
+            const expectedStale = result.daysSinceUpdate > constants.MODEL_PRICING_METADATA.staleThresholdDays;
+            assert.strictEqual(result.isStale, expectedStale);
+        });
+        it('should return non-negative daysSinceUpdate', () => {
+            const result = constants.checkPricingStaleness();
+            assert.ok(result.daysSinceUpdate >= 0);
+        });
+    });
+    describe('File patterns', () => {
+        describe('TRACES_FILE_PATTERN', () => {
+            it('should be a string', () => {
+                assert.strictEqual(typeof constants.TRACES_FILE_PATTERN, 'string');
+            });
+            it('should equal "traces-*.jsonl"', () => {
+                assert.strictEqual(constants.TRACES_FILE_PATTERN, 'traces-*.jsonl');
+            });
+        });
+        describe('LOGS_FILE_PATTERN', () => {
+            it('should be a string', () => {
+                assert.strictEqual(typeof constants.LOGS_FILE_PATTERN, 'string');
+            });
+            it('should equal "logs-*.jsonl"', () => {
+                assert.strictEqual(constants.LOGS_FILE_PATTERN, 'logs-*.jsonl');
+            });
+        });
+        describe('METRICS_FILE_PATTERN', () => {
+            it('should be a string', () => {
+                assert.strictEqual(typeof constants.METRICS_FILE_PATTERN, 'string');
+            });
+            it('should equal "metrics-*.jsonl"', () => {
+                assert.strictEqual(constants.METRICS_FILE_PATTERN, 'metrics-*.jsonl');
+            });
+        });
+        it('all patterns should end with .jsonl', () => {
+            assert(constants.TRACES_FILE_PATTERN.endsWith('.jsonl'));
+            assert(constants.LOGS_FILE_PATTERN.endsWith('.jsonl'));
+            assert(constants.METRICS_FILE_PATTERN.endsWith('.jsonl'));
+        });
+        it('all patterns should contain glob wildcard', () => {
+            assert(constants.TRACES_FILE_PATTERN.includes('*'));
+            assert(constants.LOGS_FILE_PATTERN.includes('*'));
+            assert(constants.METRICS_FILE_PATTERN.includes('*'));
+        });
+    });
+    describe('SPAN_KIND', () => {
+        it('should map to OTel proto numeric values', () => {
+            assert.strictEqual(constants.SPAN_KIND.UNSPECIFIED, 0);
+            assert.strictEqual(constants.SPAN_KIND.INTERNAL, 1);
+            assert.strictEqual(constants.SPAN_KIND.SERVER, COUNT_TWO);
+            assert.strictEqual(constants.SPAN_KIND.CLIENT, COUNT_THREE);
+            assert.strictEqual(constants.SPAN_KIND.PRODUCER, COUNT_FOUR);
+            assert.strictEqual(constants.SPAN_KIND.CONSUMER, COUNT_FIVE);
+        });
+    });
+    describe('getSpanKind', () => {
+        it('should return undefined for UNSPECIFIED (0)', () => {
+            assert.strictEqual(constants.getSpanKind(0), undefined);
+        });
+        it('should return INTERNAL for kind 1', () => {
+            assert.strictEqual(constants.getSpanKind(1), 'INTERNAL');
+        });
+        it('should return SERVER for kind 2', () => {
+            assert.strictEqual(constants.getSpanKind(COUNT_TWO), 'SERVER');
+        });
+        it('should return CLIENT for kind 3', () => {
+            assert.strictEqual(constants.getSpanKind(COUNT_THREE), 'CLIENT');
+        });
+        it('should return PRODUCER for kind 4', () => {
+            assert.strictEqual(constants.getSpanKind(COUNT_FOUR), 'PRODUCER');
+        });
+        it('should return CONSUMER for kind 5', () => {
+            assert.strictEqual(constants.getSpanKind(COUNT_FIVE), 'CONSUMER');
+        });
+        it('should return undefined for undefined kind', () => {
+            assert.strictEqual(constants.getSpanKind(undefined), undefined);
+        });
+        it('should return undefined for negative kind', () => {
+            assert.strictEqual(constants.getSpanKind(-1), undefined);
+        });
+        it('should return undefined for out-of-bounds kind', () => {
+            const COUNT_SIX = 6;
+            assert.strictEqual(constants.getSpanKind(COUNT_SIX), undefined);
+            assert.strictEqual(constants.getSpanKind(constants.DEFAULT_QUERY_RESULT_LIMIT), undefined);
+        });
+    });
+    describe('STATUS_CODES', () => {
+        it('should be an array', () => {
+            assert.ok(Array.isArray(constants.STATUS_CODES));
+        });
+        it('should have 3 status codes', () => {
+            assert.strictEqual(constants.STATUS_CODES.length, COUNT_THREE);
+        });
+        it('should have UNSET at index 0', () => {
+            assert.strictEqual(constants.STATUS_CODES[0], 'UNSET');
+        });
+        it('should have OK at index 1', () => {
+            assert.strictEqual(constants.STATUS_CODES[1], 'OK');
+        });
+        it('should have ERROR at index 2', () => {
+            assert.strictEqual(constants.STATUS_CODES[2], 'ERROR');
+        });
+    });
+    describe('getStatusCodeName', () => {
+        it('should return UNSET for code 0', () => {
+            assert.strictEqual(constants.getStatusCodeName(0), 'UNSET');
+        });
+        it('should return OK for code 1', () => {
+            assert.strictEqual(constants.getStatusCodeName(1), 'OK');
+        });
+        it('should return ERROR for code 2', () => {
+            assert.strictEqual(constants.getStatusCodeName(COUNT_TWO), 'ERROR');
+        });
+        it('should return undefined for undefined code', () => {
+            assert.strictEqual(constants.getStatusCodeName(undefined), undefined);
+        });
+        it('should return undefined for negative code', () => {
+            assert.strictEqual(constants.getStatusCodeName(-1), undefined);
+        });
+        it('should return undefined for out-of-bounds code', () => {
+            assert.strictEqual(constants.getStatusCodeName(COUNT_THREE), undefined);
+            assert.strictEqual(constants.getStatusCodeName(constants.DEFAULT_QUERY_RESULT_LIMIT), undefined);
+        });
+    });
+    describe('OTEL_LOG_SEVERITIES', () => {
+        it('should include canonical OTel log severities in order', () => {
+            assert.deepStrictEqual(constants.OTEL_LOG_SEVERITIES, ['TRACE', 'DEBUG', 'INFO', 'WARN', 'ERROR', 'FATAL']);
+        });
+    });
+    describe('getOtelLogSeverityNumber', () => {
+        it('should map canonical severity names to bucket numbers', () => {
+            assert.strictEqual(constants.getOtelLogSeverityNumber('TRACE'), constants.OTEL_LOG_SEVERITY_NUMBERS.TRACE);
+            assert.strictEqual(constants.getOtelLogSeverityNumber('DEBUG'), constants.OTEL_LOG_SEVERITY_NUMBERS.DEBUG);
+            assert.strictEqual(constants.getOtelLogSeverityNumber('INFO'), constants.OTEL_LOG_SEVERITY_NUMBERS.INFO);
+            assert.strictEqual(constants.getOtelLogSeverityNumber('WARN'), constants.OTEL_LOG_SEVERITY_NUMBERS.WARN);
+            assert.strictEqual(constants.getOtelLogSeverityNumber('ERROR'), constants.OTEL_LOG_SEVERITY_NUMBERS.ERROR);
+            assert.strictEqual(constants.getOtelLogSeverityNumber('FATAL'), constants.OTEL_LOG_SEVERITY_NUMBERS.FATAL);
+        });
+        it('should support severity aliases', () => {
+            assert.strictEqual(constants.getOtelLogSeverityNumber('warning'), constants.OTEL_LOG_SEVERITY_NUMBERS.WARN);
+            assert.strictEqual(constants.getOtelLogSeverityNumber('critical'), constants.OTEL_LOG_SEVERITY_NUMBERS.FATAL);
+        });
+        it('should return undefined for unknown or empty values', () => {
+            assert.strictEqual(constants.getOtelLogSeverityNumber(''), undefined);
+            assert.strictEqual(constants.getOtelLogSeverityNumber('verbose'), undefined);
+            assert.strictEqual(constants.getOtelLogSeverityNumber(undefined), undefined);
+        });
+    });
+    describe('getOtelLogSeverityName', () => {
+        it('should map bucket thresholds to canonical severity names', () => {
+            assert.strictEqual(constants.getOtelLogSeverityName(constants.OTEL_LOG_SEVERITY_NUMBERS.TRACE), 'TRACE');
+            assert.strictEqual(constants.getOtelLogSeverityName(constants.OTEL_LOG_SEVERITY_NUMBERS.DEBUG), 'DEBUG');
+            assert.strictEqual(constants.getOtelLogSeverityName(constants.OTEL_LOG_SEVERITY_NUMBERS.INFO), 'INFO');
+            assert.strictEqual(constants.getOtelLogSeverityName(constants.OTEL_LOG_SEVERITY_NUMBERS.WARN), 'WARN');
+            assert.strictEqual(constants.getOtelLogSeverityName(constants.OTEL_LOG_SEVERITY_NUMBERS.ERROR), 'ERROR');
+            assert.strictEqual(constants.getOtelLogSeverityName(constants.OTEL_LOG_SEVERITY_NUMBERS.FATAL), 'FATAL');
+        });
+        it('should map in-range values to containing severity buckets', () => {
+            assert.strictEqual(constants.getOtelLogSeverityName(constants.OTEL_LOG_SEVERITY_NUMBERS.WARN + 1), 'WARN');
+            assert.strictEqual(constants.getOtelLogSeverityName(constants.OTEL_LOG_SEVERITY_NUMBERS.ERROR + 1), 'ERROR');
+        });
+        it('should return undefined for values below TRACE or undefined', () => {
+            assert.strictEqual(constants.getOtelLogSeverityName(constants.OTEL_LOG_SEVERITY_NUMBERS.TRACE - 1), undefined);
+            assert.strictEqual(constants.getOtelLogSeverityName(undefined), undefined);
+        });
+    });
+    describe('getTelemetryDirectories', () => {
+        let tempDir;
+        before(() => {
+            tempDir = getSharedTempDir('ConstantsTelemetryDirs');
+        });
+        beforeEach(() => {
+            clearTempDir(tempDir);
+        });
+        after(() => {
+            removeSharedTempDir('ConstantsTelemetryDirs');
+        });
+        it('should return array of directories', () => {
+            const dirs = constants.getTelemetryDirectories(tempDir);
+            assert.ok(Array.isArray(dirs));
+        });
+        it('should include global telemetry directory if it exists', () => {
+            const dirs = constants.getTelemetryDirectories(tempDir);
+            const globalDir = dirs.find(d => d.source === 'global');
+            // Global dir is included if TELEMETRY_DIR exists
+            if (fs.existsSync(constants.TELEMETRY_DIR)) {
+                assert.ok(globalDir);
+                assert.strictEqual(globalDir?.path, constants.TELEMETRY_DIR);
+            }
+        });
+        it('should detect .claude/telemetry local directory', () => {
+            const localTelemetry = join(tempDir, '.claude', 'telemetry');
+            fs.mkdirSync(localTelemetry, { recursive: true });
+            const dirs = constants.getTelemetryDirectories(tempDir);
+            const localDir = dirs.find(d => d.source === 'local' && d.path.includes('.claude/telemetry'));
+            assert.ok(localDir);
+            // Compare against resolved path since function now resolves all paths
+            const resolvedPath = fs.realpathSync(localTelemetry);
+            assert.strictEqual(localDir?.path, resolvedPath);
+        });
+        it('should detect telemetry/ local directory', () => {
+            const localTelemetry = join(tempDir, 'telemetry');
+            fs.mkdirSync(localTelemetry, { recursive: true });
+            const dirs = constants.getTelemetryDirectories(tempDir);
+            // Compare against resolved path since function now resolves all paths
+            const resolvedPath = fs.realpathSync(localTelemetry);
+            const localDir = dirs.find(d => d.source === 'local' && d.path === resolvedPath);
+            assert.ok(localDir);
+        });
+        it('should detect .telemetry/ local directory', () => {
+            const localTelemetry = join(tempDir, '.telemetry');
+            fs.mkdirSync(localTelemetry, { recursive: true });
+            const dirs = constants.getTelemetryDirectories(tempDir);
+            // Compare against resolved path since function now resolves all paths
+            const resolvedPath = fs.realpathSync(localTelemetry);
+            const localDir = dirs.find(d => d.source === 'local' && d.path === resolvedPath);
+            assert.ok(localDir);
+        });
+        it('should detect multiple local directories', () => {
+            // Create multiple local telemetry directories
+            fs.mkdirSync(join(tempDir, 'telemetry'), { recursive: true });
+            fs.mkdirSync(join(tempDir, '.telemetry'), { recursive: true });
+            const dirs = constants.getTelemetryDirectories(tempDir);
+            const localDirs = dirs.filter(d => d.source === 'local');
+            assert.ok(localDirs.length >= COUNT_TWO);
+        });
+        it('should not include non-existent local directories', () => {
+            // Don't create any local directories
+            const dirs = constants.getTelemetryDirectories(tempDir);
+            const localDirs = dirs.filter(d => d.source === 'local');
+            // Should not include any local dirs for this temp directory
+            assert.strictEqual(localDirs.length, 0);
+        });
+        it('should avoid duplicate paths', () => {
+            // Create a telemetry directory
+            const localTelemetry = join(tempDir, 'telemetry');
+            fs.mkdirSync(localTelemetry, { recursive: true });
+            const dirs = constants.getTelemetryDirectories(tempDir);
+            const paths = dirs.map(d => d.path);
+            const uniquePaths = new Set(paths);
+            assert.strictEqual(paths.length, uniquePaths.size, 'Should not have duplicate paths');
+        });
+        it('should use process.cwd() when cwd not provided', () => {
+            const dirs = constants.getTelemetryDirectories();
+            assert.ok(Array.isArray(dirs));
+        });
+        it('should return directories with correct source labels', () => {
+            fs.mkdirSync(join(tempDir, 'telemetry'), { recursive: true });
+            const dirs = constants.getTelemetryDirectories(tempDir);
+            for (const dir of dirs) {
+                assert.ok(['global', 'local'].includes(dir.source));
+                assert.ok(typeof dir.path === 'string');
+                assert.ok(dir.path.length > 0);
+            }
+        });
+        describe('symlink path traversal protection', () => {
+            it('should reject symlinks pointing outside allowed directories', () => {
+                // Create a symlink that points to /tmp (outside allowed directories)
+                const symlinkPath = join(tempDir, 'telemetry');
+                const outsideDir = fs.mkdtempSync(join(os.tmpdir(), 'outside-'));
+                try {
+                    fs.symlinkSync(outsideDir, symlinkPath);
+                    // The symlink should NOT be included because it points outside allowed dirs
+                    const dirs = constants.getTelemetryDirectories(tempDir);
+                    const localDirs = dirs.filter(d => d.source === 'local');
+                    // The symlink should be rejected
+                    const hasSymlinkTarget = localDirs.some(d => d.path === outsideDir || d.path === symlinkPath);
+                    assert.strictEqual(hasSymlinkTarget, false, 'Symlink pointing outside allowed dirs should be rejected');
+                }
+                finally {
+                    try {
+                        fs.unlinkSync(symlinkPath);
+                        fs.rmSync(outsideDir, { recursive: true, force: true });
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                }
+            });
+            it('should accept symlinks pointing within allowed directories', () => {
+                // Create a real telemetry directory within the temp dir
+                const realTelemetry = join(tempDir, 'real-telemetry');
+                fs.mkdirSync(realTelemetry, { recursive: true });
+                // Create a symlink to it from .telemetry
+                const symlinkPath = join(tempDir, '.telemetry');
+                try {
+                    fs.symlinkSync(realTelemetry, symlinkPath);
+                    const dirs = constants.getTelemetryDirectories(tempDir);
+                    const localDirs = dirs.filter(d => d.source === 'local');
+                    // The symlink should be accepted and resolved to the real path
+                    // Note: On macOS, /var is a symlink to /private/var, so we need to compare
+                    // against the fully resolved path using realpathSync
+                    const resolvedRealTelemetry = fs.realpathSync(realTelemetry);
+                    const hasRealPath = localDirs.some(d => d.path === resolvedRealTelemetry);
+                    assert.ok(hasRealPath, 'Symlink within allowed dirs should resolve to real path');
+                }
+                finally {
+                    try {
+                        fs.unlinkSync(symlinkPath);
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                }
+            });
+            it('should handle broken symlinks gracefully', () => {
+                // Create a symlink pointing to a non-existent path
+                const symlinkPath = join(tempDir, 'telemetry');
+                const nonExistentPath = join(tempDir, 'does-not-exist-anywhere');
+                try {
+                    fs.symlinkSync(nonExistentPath, symlinkPath);
+                    // The broken symlink should be handled gracefully (existsSync returns false)
+                    const dirs = constants.getTelemetryDirectories(tempDir);
+                    const localDirs = dirs.filter(d => d.source === 'local');
+                    // Broken symlinks should not be included
+                    const hasBrokenSymlink = localDirs.some(d => d.path === symlinkPath);
+                    assert.strictEqual(hasBrokenSymlink, false, 'Broken symlinks should not be included');
+                }
+                finally {
+                    try {
+                        fs.unlinkSync(symlinkPath);
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                }
+            });
+            it('should not follow symlink chains that escape allowed directories', () => {
+                // Create a directory outside temp
+                const outsideDir = fs.mkdtempSync(join(os.tmpdir(), 'chain-outside-'));
+                const intermediateDir = join(tempDir, 'intermediate');
+                fs.mkdirSync(intermediateDir, { recursive: true });
+                // Create a symlink in intermediate pointing outside
+                const intermediateLink = join(intermediateDir, 'escape');
+                try {
+                    fs.symlinkSync(outsideDir, intermediateLink);
+                    // Create telemetry symlink pointing to the intermediate escape link
+                    const telemetryLink = join(tempDir, 'telemetry');
+                    fs.symlinkSync(intermediateLink, telemetryLink);
+                    const dirs = constants.getTelemetryDirectories(tempDir);
+                    const localDirs = dirs.filter(d => d.source === 'local');
+                    // Neither the symlink nor its chain target should be included
+                    const hasEscapedPath = localDirs.some(d => d.path === outsideDir || d.path === telemetryLink || d.path === intermediateLink);
+                    assert.strictEqual(hasEscapedPath, false, 'Symlink chains escaping allowed dirs should be rejected');
+                    fs.unlinkSync(telemetryLink);
+                }
+                finally {
+                    try {
+                        fs.unlinkSync(intermediateLink);
+                        fs.rmSync(outsideDir, { recursive: true, force: true });
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                }
+            });
+            it('should resolve real paths to avoid duplicates from symlinks', () => {
+                // Create a real telemetry directory
+                const realTelemetry = join(tempDir, 'real-telemetry');
+                fs.mkdirSync(realTelemetry, { recursive: true });
+                // Create two symlinks pointing to the same real directory
+                const symlinkPath1 = join(tempDir, 'telemetry');
+                const symlinkPath2 = join(tempDir, '.telemetry');
+                try {
+                    fs.symlinkSync(realTelemetry, symlinkPath1);
+                    fs.symlinkSync(realTelemetry, symlinkPath2);
+                    const dirs = constants.getTelemetryDirectories(tempDir);
+                    const localDirs = dirs.filter(d => d.source === 'local');
+                    // Both symlinks resolve to the same real path, so only one entry
+                    // Note: On macOS, /var is a symlink to /private/var, so compare resolved paths
+                    const resolvedRealTelemetry = fs.realpathSync(realTelemetry);
+                    const realPathCount = localDirs.filter(d => d.path === resolvedRealTelemetry).length;
+                    assert.strictEqual(realPathCount, 1, 'Multiple symlinks to same target should only appear once');
+                }
+                finally {
+                    try {
+                        fs.unlinkSync(symlinkPath1);
+                        fs.unlinkSync(symlinkPath2);
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                }
+            });
+            it('should use atomic path check to prevent TOCTOU race conditions', () => {
+                // This test verifies that the implementation uses atomic operations
+                // by checking that both symlink detection and resolution happen together
+                const realTelemetry = join(tempDir, 'atomic-test-target');
+                fs.mkdirSync(realTelemetry, { recursive: true });
+                const symlinkPath = join(tempDir, 'telemetry');
+                try {
+                    fs.symlinkSync(realTelemetry, symlinkPath);
+                    // Call getTelemetryDirectories - it should atomically check and resolve
+                    const dirs = constants.getTelemetryDirectories(tempDir);
+                    const localDirs = dirs.filter(d => d.source === 'local');
+                    // The resolved path should be the real target
+                    const resolvedRealTelemetry = fs.realpathSync(realTelemetry);
+                    const hasAtomicallyResolved = localDirs.some(d => d.path === resolvedRealTelemetry);
+                    assert.ok(hasAtomicallyResolved, 'Should atomically resolve symlink to real path');
+                    // Should NOT contain the symlink path itself
+                    const hasSymlinkPath = localDirs.some(d => d.path === symlinkPath);
+                    assert.strictEqual(hasSymlinkPath, false, 'Should use resolved path, not symlink path');
+                }
+                finally {
+                    try {
+                        fs.unlinkSync(symlinkPath);
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                }
+            });
+            it('should reject symlinks pointing to files (not directories)', () => {
+                // Create a file instead of a directory
+                const targetFile = join(tempDir, 'target-file.txt');
+                fs.writeFileSync(targetFile, 'test content');
+                const symlinkPath = join(tempDir, 'telemetry');
+                try {
+                    fs.symlinkSync(targetFile, symlinkPath);
+                    const dirs = constants.getTelemetryDirectories(tempDir);
+                    const localDirs = dirs.filter(d => d.source === 'local');
+                    // Symlink to file should be rejected (telemetry must be a directory)
+                    const hasFileSymlink = localDirs.some(d => d.path === targetFile || d.path === symlinkPath);
+                    assert.strictEqual(hasFileSymlink, false, 'Symlink to file should be rejected');
+                }
+                finally {
+                    try {
+                        fs.unlinkSync(symlinkPath);
+                        fs.unlinkSync(targetFile);
+                    }
+                    catch {
+                        // Ignore cleanup errors
+                    }
+                }
+            });
+            it('should handle permission denied errors gracefully', () => {
+                // This test verifies error handling in atomic path check
+                // Create a directory with restricted permissions (if possible)
+                const restrictedDir = join(tempDir, 'restricted');
+                fs.mkdirSync(restrictedDir, { recursive: true });
+                // Note: On some systems, we may not be able to test permission denied
+                // This test verifies the function doesn't throw on inaccessible paths
+                const dirs = constants.getTelemetryDirectories(tempDir);
+                assert.ok(Array.isArray(dirs), 'Should return array even with permission issues');
+            });
+        });
+    });
+    describe('getApiKey()', () => {
+        let savedObtoolApiKey;
+        let savedOtelApiKey;
+        beforeEach(() => {
+            savedObtoolApiKey = process.env.OBTOOL_API_KEY;
+            savedOtelApiKey = process.env.OTEL_API_KEY;
+            delete process.env.OBTOOL_API_KEY;
+            delete process.env.OTEL_API_KEY;
+        });
+        afterEach(() => {
+            if (savedObtoolApiKey === undefined) {
+                delete process.env.OBTOOL_API_KEY;
+            }
+            else {
+                process.env.OBTOOL_API_KEY = savedObtoolApiKey;
+            }
+            if (savedOtelApiKey === undefined) {
+                delete process.env.OTEL_API_KEY;
+            }
+            else {
+                process.env.OTEL_API_KEY = savedOtelApiKey;
+            }
+        });
+        it('should return OBTOOL_API_KEY env var when set', () => {
+            process.env.OBTOOL_API_KEY = 'obtool-key-abc123';
+            assert.strictEqual(constants.getApiKey(), 'obtool-key-abc123');
+        });
+        it('should fall back to OTEL_API_KEY when OBTOOL_API_KEY is not set', () => {
+            process.env.OTEL_API_KEY = 'otel-key-xyz789';
+            assert.strictEqual(constants.getApiKey(), 'otel-key-xyz789');
+        });
+        it('should return empty string when neither OBTOOL_API_KEY nor OTEL_API_KEY is set', () => {
+            assert.strictEqual(constants.getApiKey(), '');
+        });
+        it('should prefer OBTOOL_API_KEY over OTEL_API_KEY when both are set', () => {
+            process.env.OBTOOL_API_KEY = 'primary-key';
+            process.env.OTEL_API_KEY = 'fallback-key';
+            assert.strictEqual(constants.getApiKey(), 'primary-key');
+        });
+        it('should read lazily so env var set after module import is picked up', () => {
+            // At module load time OBTOOL_API_KEY was not set — this verifies
+            // getApiKey() reads process.env at call-time, not at import time.
+            process.env.OBTOOL_API_KEY = 'set-after-import';
+            assert.strictEqual(constants.getApiKey(), 'set-after-import');
+        });
+    });
+    // --- Regression guards (ST-BF) ---
+    describe('regression guards', () => {
+        it('MAX_DURATION_MS equals TIME_MS.DAY (BF-1 regression)', () => {
+            // BF-1: MAX_DURATION_MS was accidentally changed to a different value.
+            // This guard ensures MAX_DURATION_MS stays equal to exactly one day in ms.
+            assert.strictEqual(constants.MAX_DURATION_MS, units.TIME_MS.DAY, 'MAX_DURATION_MS must equal TIME_MS.DAY — update this test if the intent changes');
+        });
+    });
+});
+//# sourceMappingURL=constants.test.js.map