observability-toolkit 1.1.0 → 1.4.0

package/dist/lib/file-utils.test.js

@@ -0,0 +1,649 @@
+import { describe, it, beforeEach, afterEach } from 'node:test';
+import assert from 'node:assert';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { expandTilde, loadJson, loadJsonSafe, getDateString, listFiles, parseDateFromFilename, readJsonlSync, readJsonlSyncWithStats, streamJsonl, filterByDateRange, paginateResults, hasReachedLimit, cleanupOldFiles, } from './file-utils.js';
+describe('file-utils', () => {
+    let testDir;
+    beforeEach(() => {
+        // Create a unique temp directory for each test
+        testDir = fs.mkdtempSync(path.join(os.tmpdir(), 'file-utils-test-'));
+    });
+    afterEach(() => {
+        // Clean up temp directory
+        if (testDir && fs.existsSync(testDir)) {
+            fs.rmSync(testDir, { recursive: true, force: true });
+        }
+    });
+    describe('expandTilde', () => {
+        it('should return path as-is if it does not start with tilde', () => {
+            const result = expandTilde('/absolute/path');
+            assert.strictEqual(result, '/absolute/path');
+        });
+        it('should expand tilde to home directory for ~ alone', () => {
+            const result = expandTilde('~');
+            assert.strictEqual(result, os.homedir());
+        });
+        it('should expand tilde to home directory for ~/path', () => {
+            const result = expandTilde('~/documents/file.txt');
+            assert.strictEqual(result, path.join(os.homedir(), 'documents/file.txt'));
+        });
+        it('should return ~user/path as-is (not supported)', () => {
+            const result = expandTilde('~someuser/path');
+            assert.strictEqual(result, '~someuser/path');
+        });
+        it('should handle multiple directory levels', () => {
+            const result = expandTilde('~/a/b/c/d');
+            assert.strictEqual(result, path.join(os.homedir(), 'a/b/c/d'));
+        });
+    });
+    describe('loadJson', () => {
+        it('should load and parse valid JSON file', () => {
+            const testData = { key: 'value', num: 42 };
+            const filePath = path.join(testDir, 'test.json');
+            fs.writeFileSync(filePath, JSON.stringify(testData));
+            const result = loadJson(filePath);
+            assert.deepStrictEqual(result, testData);
+        });
+        it('should return null if file does not exist', () => {
+            const result = loadJson(path.join(testDir, 'nonexistent.json'));
+            assert.strictEqual(result, null);
+        });
+        it('should return null on JSON parse error', () => {
+            const filePath = path.join(testDir, 'invalid.json');
+            fs.writeFileSync(filePath, 'invalid json {');
+            const result = loadJson(filePath);
+            assert.strictEqual(result, null);
+        });
+        it('should return fallback value if file does not exist', () => {
+            const fallback = { default: true };
+            const result = loadJson(path.join(testDir, 'nonexistent.json'), fallback);
+            assert.deepStrictEqual(result, fallback);
+        });
+        it('should return fallback value on parse error', () => {
+            const fallback = { default: true };
+            const filePath = path.join(testDir, 'invalid.json');
+            fs.writeFileSync(filePath, 'invalid json');
+            const result = loadJson(filePath, fallback);
+            assert.deepStrictEqual(result, fallback);
+        });
+        it('should handle empty JSON file', () => {
+            const filePath = path.join(testDir, 'empty.json');
+            fs.writeFileSync(filePath, '');
+            const result = loadJson(filePath);
+            assert.strictEqual(result, null);
+        });
+        it('should parse complex nested JSON', () => {
+            const testData = {
+                nested: { deep: { value: 'test' } },
+                array: [1, 2, 3],
+            };
+            const filePath = path.join(testDir, 'complex.json');
+            fs.writeFileSync(filePath, JSON.stringify(testData));
+            const result = loadJson(filePath);
+            assert.deepStrictEqual(result, testData);
+        });
+    });
+    describe('loadJsonSafe', () => {
+        it('should return loaded JSON if file exists and is valid', () => {
+            const testData = { key: 'value' };
+            const fallback = { fallback: true };
+            const filePath = path.join(testDir, 'test.json');
+            fs.writeFileSync(filePath, JSON.stringify(testData));
+            const result = loadJsonSafe(filePath, fallback);
+            assert.deepStrictEqual(result, testData);
+        });
+        it('should return fallback if file does not exist', () => {
+            const fallback = { fallback: true };
+            const result = loadJsonSafe(path.join(testDir, 'nonexistent.json'), fallback);
+            assert.deepStrictEqual(result, fallback);
+        });
+        it('should return fallback on parse error', () => {
+            const fallback = { fallback: true };
+            const filePath = path.join(testDir, 'invalid.json');
+            fs.writeFileSync(filePath, 'invalid json');
+            const result = loadJsonSafe(filePath, fallback);
+            assert.deepStrictEqual(result, fallback);
+        });
+        it('should never return null', () => {
+            const fallback = { key: 'default' };
+            const result = loadJsonSafe(path.join(testDir, 'nonexistent.json'), fallback);
+            assert.notStrictEqual(result, null);
+        });
+    });
+    describe('getDateString', () => {
+        it('should format date as YYYY-MM-DD', () => {
+            const date = new Date('2026-01-28T12:34:56.789Z');
+            const result = getDateString(date);
+            assert.strictEqual(result, '2026-01-28');
+        });
+        it('should use current date if none provided', () => {
+            const result = getDateString();
+            const now = new Date();
+            const expected = now.toISOString().split('T')[0];
+            assert.strictEqual(result, expected);
+        });
+        it('should handle leap year date', () => {
+            const date = new Date('2024-02-29T00:00:00.000Z');
+            const result = getDateString(date);
+            assert.strictEqual(result, '2024-02-29');
+        });
+        it('should handle year boundary', () => {
+            const date = new Date('2025-12-31T23:59:59.999Z');
+            const result = getDateString(date);
+            assert.strictEqual(result, '2025-12-31');
+        });
+        it('should handle January 1st', () => {
+            const date = new Date('2026-01-01T00:00:00.000Z');
+            const result = getDateString(date);
+            assert.strictEqual(result, '2026-01-01');
+        });
+    });
+    describe('listFiles', () => {
+        it('should return empty array if directory does not exist', () => {
+            const result = listFiles(path.join(testDir, 'nonexistent'), /\.json$/);
+            assert.deepStrictEqual(result, []);
+        });
+        it('should filter files by pattern', () => {
+            fs.writeFileSync(path.join(testDir, 'file1.json'), '{}');
+            fs.writeFileSync(path.join(testDir, 'file2.json'), '{}');
+            fs.writeFileSync(path.join(testDir, 'file3.txt'), 'text');
+            fs.writeFileSync(path.join(testDir, 'file4.json'), '{}');
+            const result = listFiles(testDir, /\.json$/);
+            assert.strictEqual(result.length, 3);
+            assert(result.every(f => f.endsWith('.json')));
+        });
+        it('should return full paths', () => {
+            fs.writeFileSync(path.join(testDir, 'file1.json'), '{}');
+            fs.writeFileSync(path.join(testDir, 'file2.json'), '{}');
+            const result = listFiles(testDir, /\.json$/);
+            assert(result.every(f => f.startsWith(testDir)));
+        });
+        it('should sort by modification time (newest first)', async () => {
+            // Create files with different modification times
+            const file1 = path.join(testDir, 'file1.json');
+            const file2 = path.join(testDir, 'file2.json');
+            const file3 = path.join(testDir, 'file3.json');
+            fs.writeFileSync(file1, '{}');
+            // Small delay to ensure different mtimes
+            await new Promise(resolve => setTimeout(resolve, 50));
+            fs.writeFileSync(file2, '{}');
+            await new Promise(resolve => setTimeout(resolve, 50));
+            fs.writeFileSync(file3, '{}');
+            const result = listFiles(testDir, /\.json$/);
+            assert.strictEqual(result[0], file3); // newest first
+            assert.strictEqual(result[1], file2);
+            assert.strictEqual(result[2], file1); // oldest last
+        });
+        it('should handle empty directory', () => {
+            const result = listFiles(testDir, /\.json$/);
+            assert.deepStrictEqual(result, []);
+        });
+        it('should match complex regex patterns', () => {
+            fs.writeFileSync(path.join(testDir, 'traces-2026-01-28.jsonl'), '{}');
+            fs.writeFileSync(path.join(testDir, 'metrics-2026-01-28.jsonl'), '{}');
+            fs.writeFileSync(path.join(testDir, 'logs-2026-01-28.jsonl'), '{}');
+            fs.writeFileSync(path.join(testDir, 'other.txt'), 'text');
+            const result = listFiles(testDir, /^\w+-\d{4}-\d{2}-\d{2}\.jsonl$/);
+            assert.strictEqual(result.length, 3);
+        });
+    });
+    describe('parseDateFromFilename', () => {
+        it('should extract date from filename with format traces-YYYY-MM-DD.jsonl', () => {
+            const result = parseDateFromFilename('traces-2026-01-28.jsonl');
+            assert.strictEqual(result, '2026-01-28');
+        });
+        it('should extract date from filename with format metrics-YYYY-MM-DD.jsonl', () => {
+            const result = parseDateFromFilename('metrics-2026-12-25.jsonl');
+            assert.strictEqual(result, '2026-12-25');
+        });
+        it('should return null if no date found', () => {
+            const result = parseDateFromFilename('nodatehere.jsonl');
+            assert.strictEqual(result, null);
+        });
+        it('should handle full path', () => {
+            const result = parseDateFromFilename('/path/to/traces-2026-01-28.jsonl');
+            assert.strictEqual(result, '2026-01-28');
+        });
+        it('should extract first matching date pattern', () => {
+            const result = parseDateFromFilename('traces-2026-01-28-backup-2026-01-29.jsonl');
+            assert.strictEqual(result, '2026-01-28');
+        });
+        it('should handle invalid date numbers', () => {
+            const result = parseDateFromFilename('file-9999-99-99.jsonl');
+            assert.strictEqual(result, '9999-99-99');
+        });
+        it('should return null for incomplete date patterns', () => {
+            const result = parseDateFromFilename('file-2026-01.jsonl');
+            assert.strictEqual(result, null);
+        });
+        it('should handle leap year date', () => {
+            const result = parseDateFromFilename('traces-2024-02-29.jsonl');
+            assert.strictEqual(result, '2024-02-29');
+        });
+    });
+    describe('readJsonlSync', () => {
+        it('should return empty array if file does not exist', () => {
+            const result = readJsonlSync(path.join(testDir, 'nonexistent.jsonl'));
+            assert.deepStrictEqual(result, []);
+        });
+        it('should parse JSONL file with multiple lines', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1,"name":"first"}\n{"id":2,"name":"second"}\n{"id":3,"name":"third"}');
+            const result = readJsonlSync(filePath);
+            assert.strictEqual(result.length, 3);
+            assert.deepStrictEqual(result[0], { id: 1, name: 'first' });
+            assert.deepStrictEqual(result[1], { id: 2, name: 'second' });
+            assert.deepStrictEqual(result[2], { id: 3, name: 'third' });
+        });
+        it('should skip empty lines', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n\n{"id":2}\n   \n{"id":3}');
+            const result = readJsonlSync(filePath);
+            assert.strictEqual(result.length, 3);
+        });
+        it('should skip malformed JSON lines', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n{invalid json}\n{"id":2}');
+            const result = readJsonlSync(filePath);
+            assert.strictEqual(result.length, 2);
+            assert.deepStrictEqual(result[0], { id: 1 });
+            assert.deepStrictEqual(result[1], { id: 2 });
+        });
+        it('should respect limit parameter', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n{"id":2}\n{"id":3}\n{"id":4}\n{"id":5}');
+            const result = readJsonlSync(filePath, 3);
+            assert.strictEqual(result.length, 3);
+        });
+        it('should stop reading at limit even with more lines', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n{"id":2}\n{"id":3}\n{"id":4}');
+            const result = readJsonlSync(filePath, 2);
+            assert.strictEqual(result.length, 2);
+            assert.deepStrictEqual(result[1], { id: 2 });
+        });
+        it('should handle file with trailing whitespace', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n{"id":2}\n   ');
+            const result = readJsonlSync(filePath);
+            assert.strictEqual(result.length, 2);
+        });
+        it('should handle single line file', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}');
+            const result = readJsonlSync(filePath);
+            assert.strictEqual(result.length, 1);
+            assert.deepStrictEqual(result[0], { id: 1 });
+        });
+        it('should handle complex JSON objects', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"nested":{"deep":{"value":1}}}\n{"array":[1,2,3]}');
+            const result = readJsonlSync(filePath);
+            assert.deepStrictEqual(result[0], { nested: { deep: { value: 1 } } });
+            assert.deepStrictEqual(result[1], { array: [1, 2, 3] });
+        });
+    });
+    describe('streamJsonl', () => {
+        it('should yield nothing if file does not exist', async () => {
+            const results = [];
+            for await (const item of streamJsonl(path.join(testDir, 'nonexistent.jsonl'))) {
+                results.push(item);
+            }
+            assert.strictEqual(results.length, 0);
+        });
+        it('should yield parsed JSON objects from file', async () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n{"id":2}\n{"id":3}');
+            const results = [];
+            for await (const item of streamJsonl(filePath)) {
+                results.push(item);
+            }
+            assert.strictEqual(results.length, 3);
+            assert.deepStrictEqual(results[0], { id: 1 });
+            assert.deepStrictEqual(results[1], { id: 2 });
+            assert.deepStrictEqual(results[2], { id: 3 });
+        });
+        it('should skip empty lines', async () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n\n  \n{"id":2}');
+            const results = [];
+            for await (const item of streamJsonl(filePath)) {
+                results.push(item);
+            }
+            assert.strictEqual(results.length, 2);
+        });
+        it('should skip malformed JSON lines', async () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n{invalid}\n{"id":2}');
+            const results = [];
+            for await (const item of streamJsonl(filePath)) {
+                results.push(item);
+            }
+            assert.strictEqual(results.length, 2);
+            assert.deepStrictEqual(results[0], { id: 1 });
+            assert.deepStrictEqual(results[1], { id: 2 });
+        });
+        it('should handle large JSONL files efficiently', async () => {
+            const filePath = path.join(testDir, 'large.jsonl');
+            const lines = Array.from({ length: 1000 }, (_, i) => JSON.stringify({ id: i })).join('\n');
+            fs.writeFileSync(filePath, lines);
+            let count = 0;
+            for await (const _item of streamJsonl(filePath)) {
+                count++;
+            }
+            assert.strictEqual(count, 1000);
+        });
+    });
+    describe('filterByDateRange', () => {
+        const items = [
+            { id: 1, timestamp: '2026-01-10' },
+            { id: 2, timestamp: '2026-01-15' },
+            { id: 3, timestamp: '2026-01-20' },
+            { id: 4, timestamp: '2026-01-25' },
+        ];
+        it('should return all items if no date range specified', () => {
+            const result = filterByDateRange(items);
+            assert.strictEqual(result.length, 4);
+        });
+        it('should filter items after startDate', () => {
+            const result = filterByDateRange(items, '2026-01-15');
+            assert.strictEqual(result.length, 3);
+            assert.deepStrictEqual(result[0], { id: 2, timestamp: '2026-01-15' });
+        });
+        it('should filter items before endDate', () => {
+            const result = filterByDateRange(items, undefined, '2026-01-20');
+            assert.strictEqual(result.length, 3);
+            assert.deepStrictEqual(result[2], { id: 3, timestamp: '2026-01-20' });
+        });
+        it('should filter items between startDate and endDate', () => {
+            const result = filterByDateRange(items, '2026-01-12', '2026-01-22');
+            assert.strictEqual(result.length, 2);
+            assert.deepStrictEqual(result[0], { id: 2, timestamp: '2026-01-15' });
+            assert.deepStrictEqual(result[1], { id: 3, timestamp: '2026-01-20' });
+        });
+        it('should include items with exact startDate', () => {
+            const result = filterByDateRange(items, '2026-01-15');
+            assert(result.some(item => item.id === 2));
+        });
+        it('should include items with exact endDate', () => {
+            const result = filterByDateRange(items, undefined, '2026-01-15');
+            assert(result.some(item => item.id === 2));
+        });
+        it('should include items without timestamp', () => {
+            const itemsWithoutTs = [
+                { id: 1, timestamp: '2026-01-10' },
+                { id: 2 },
+                { id: 3, timestamp: '2026-01-20' },
+            ];
+            const result = filterByDateRange(itemsWithoutTs, '2026-01-15');
+            assert.strictEqual(result.length, 2);
+            assert(result.some(item => item.id === 2));
+        });
+        it('should return empty array if no items in range', () => {
+            const result = filterByDateRange(items, '2026-02-01', '2026-02-28');
+            assert.deepStrictEqual(result, []);
+        });
+        it('should handle empty items array', () => {
+            const result = filterByDateRange([], '2026-01-01', '2026-12-31');
+            assert.deepStrictEqual(result, []);
+        });
+        it('should work with time component in timestamp', () => {
+            const itemsWithTime = [
+                { id: 1, timestamp: '2026-01-15T10:00:00' },
+                { id: 2, timestamp: '2026-01-15T15:00:00' },
+                { id: 3, timestamp: '2026-01-16T10:00:00' },
+            ];
+            // Note: filterByDateRange uses lexicographic comparison
+            // '2026-01-15T...' > '2026-01-15' due to 'T', so use end of day
+            const result = filterByDateRange(itemsWithTime, '2026-01-15', '2026-01-15T23:59:59');
+            assert.strictEqual(result.length, 2);
+        });
+        it('should handle lexicographic string comparison correctly', () => {
+            const itemsWithDates = [
+                { id: 1, timestamp: '2026-01-01' },
+                { id: 2, timestamp: '2026-02-01' },
+                { id: 3, timestamp: '2026-10-01' },
+            ];
+            const result = filterByDateRange(itemsWithDates, '2026-02-01', '2026-10-01');
+            assert.strictEqual(result.length, 2);
+        });
+        it('should handle generic type with optional timestamp', () => {
+            const customItems = [
+                { name: 'item1', timestamp: '2026-01-10' },
+                { name: 'item2' },
+            ];
+            const result = filterByDateRange(customItems, '2026-01-09', '2026-01-11');
+            assert.strictEqual(result.length, 2);
+        });
+    });
+    describe('paginateResults', () => {
+        const items = [1, 2, 3, 4, 5, 6, 7, 8, 9, 10];
+        it('should return items from offset to offset + limit', () => {
+            const result = paginateResults(items, 2, 3);
+            assert.deepStrictEqual(result, [3, 4, 5]);
+        });
+        it('should return from start when offset is 0', () => {
+            const result = paginateResults(items, 0, 5);
+            assert.deepStrictEqual(result, [1, 2, 3, 4, 5]);
+        });
+        it('should handle offset at end of array', () => {
+            const result = paginateResults(items, 8, 5);
+            assert.deepStrictEqual(result, [9, 10]);
+        });
+        it('should return empty array when offset exceeds length', () => {
+            const result = paginateResults(items, 15, 5);
+            assert.deepStrictEqual(result, []);
+        });
+        it('should handle limit larger than remaining items', () => {
+            const result = paginateResults(items, 7, 10);
+            assert.deepStrictEqual(result, [8, 9, 10]);
+        });
+        it('should handle empty array', () => {
+            const result = paginateResults([], 0, 10);
+            assert.deepStrictEqual(result, []);
+        });
+        it('should work with object arrays', () => {
+            const objs = [{ id: 1 }, { id: 2 }, { id: 3 }];
+            const result = paginateResults(objs, 1, 2);
+            assert.deepStrictEqual(result, [{ id: 2 }, { id: 3 }]);
+        });
+    });
+    describe('hasReachedLimit', () => {
+        it('should return true when results equal offset + limit', () => {
+            const result = hasReachedLimit(10, 5, 5);
+            assert.strictEqual(result, true);
+        });
+        it('should return true when results exceed offset + limit', () => {
+            const result = hasReachedLimit(15, 5, 5);
+            assert.strictEqual(result, true);
+        });
+        it('should return false when results are less than offset + limit', () => {
+            const result = hasReachedLimit(8, 5, 5);
+            assert.strictEqual(result, false);
+        });
+        it('should return false with zero results', () => {
+            const result = hasReachedLimit(0, 0, 10);
+            assert.strictEqual(result, false);
+        });
+        it('should handle zero offset', () => {
+            const result = hasReachedLimit(10, 0, 10);
+            assert.strictEqual(result, true);
+        });
+    });
+    describe('readJsonlSyncWithStats', () => {
+        it('should return data and stats', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n{"id":2}\n{"id":3}');
+            const result = readJsonlSyncWithStats(filePath);
+            assert.ok('data' in result);
+            assert.ok('stats' in result);
+            assert.strictEqual(result.data.length, 3);
+            assert.strictEqual(result.stats.totalLines, 3);
+            assert.strictEqual(result.stats.parsedLines, 3);
+            assert.strictEqual(result.stats.skippedLines, 0);
+            assert.strictEqual(result.stats.emptyLines, 0);
+        });
+        it('should count skipped lines', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n{invalid json}\n{"id":2}\n{also invalid}');
+            const result = readJsonlSyncWithStats(filePath);
+            assert.strictEqual(result.data.length, 2);
+            assert.strictEqual(result.stats.parsedLines, 2);
+            assert.strictEqual(result.stats.skippedLines, 2);
+        });
+        it('should count empty lines', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            // Note: trailing empty lines are removed by trim(), so only internal empty lines are counted
+            fs.writeFileSync(filePath, '{"id":1}\n\n  \n{"id":2}');
+            const result = readJsonlSyncWithStats(filePath);
+            assert.strictEqual(result.data.length, 2);
+            assert.strictEqual(result.stats.emptyLines, 2);
+        });
+        it('should respect limit parameter', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n{"id":2}\n{"id":3}\n{"id":4}\n{"id":5}');
+            const result = readJsonlSyncWithStats(filePath, 3);
+            assert.strictEqual(result.data.length, 3);
+            assert.strictEqual(result.stats.parsedLines, 3);
+        });
+        it('should return empty stats for non-existent file', () => {
+            const result = readJsonlSyncWithStats(path.join(testDir, 'nonexistent.jsonl'));
+            assert.deepStrictEqual(result.data, []);
+            assert.strictEqual(result.stats.totalLines, 0);
+            assert.strictEqual(result.stats.parsedLines, 0);
+        });
+        it('should track all stats together', () => {
+            const filePath = path.join(testDir, 'test.jsonl');
+            fs.writeFileSync(filePath, '{"id":1}\n\n{bad}\n{"id":2}\n  \n{invalid}\n{"id":3}');
+            const result = readJsonlSyncWithStats(filePath);
+            assert.strictEqual(result.data.length, 3);
+            assert.strictEqual(result.stats.totalLines, 7);
+            assert.strictEqual(result.stats.parsedLines, 3);
+            assert.strictEqual(result.stats.skippedLines, 2);
+            assert.strictEqual(result.stats.emptyLines, 2);
+        });
+    });
+    describe('cleanupOldFiles', () => {
+        it('should return empty result for non-existent directory', () => {
+            const result = cleanupOldFiles(path.join(testDir, 'nonexistent'));
+            assert.strictEqual(result.deleted, 0);
+            assert.deepStrictEqual(result.errors, []);
+        });
+        it('should delete files older than retention period', () => {
+            // Create files with dates in the past
+            const oldDate = '2020-01-01';
+            const recentDate = new Date().toISOString().split('T')[0];
+            fs.writeFileSync(path.join(testDir, `traces-${oldDate}.jsonl`), '{}');
+            fs.writeFileSync(path.join(testDir, `logs-${oldDate}.jsonl`), '{}');
+            fs.writeFileSync(path.join(testDir, `traces-${recentDate}.jsonl`), '{}');
+            const result = cleanupOldFiles(testDir, 7);
+            assert.strictEqual(result.deleted, 2);
+            assert.deepStrictEqual(result.errors, []);
+            // Verify old files are deleted
+            assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${oldDate}.jsonl`)), false);
+            assert.strictEqual(fs.existsSync(path.join(testDir, `logs-${oldDate}.jsonl`)), false);
+            // Verify recent file is kept
+            assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${recentDate}.jsonl`)), true);
+        });
+        it('should not delete files within retention period', () => {
+            const today = new Date();
+            const yesterday = new Date(today.getTime() - 24 * 60 * 60 * 1000);
+            const yesterdayStr = yesterday.toISOString().split('T')[0];
+            fs.writeFileSync(path.join(testDir, `traces-${yesterdayStr}.jsonl`), '{}');
+            const result = cleanupOldFiles(testDir, 7);
+            assert.strictEqual(result.deleted, 0);
+            assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${yesterdayStr}.jsonl`)), true);
+        });
+        it('should skip files without parseable dates', () => {
+            fs.writeFileSync(path.join(testDir, 'some-random-file.jsonl'), '{}');
+            fs.writeFileSync(path.join(testDir, 'no-date.jsonl'), '{}');
+            const result = cleanupOldFiles(testDir, 7);
+            assert.strictEqual(result.deleted, 0);
+            assert.strictEqual(fs.existsSync(path.join(testDir, 'some-random-file.jsonl')), true);
+            assert.strictEqual(fs.existsSync(path.join(testDir, 'no-date.jsonl')), true);
+        });
+        it('should only process .jsonl files', () => {
+            const oldDate = '2020-01-01';
+            fs.writeFileSync(path.join(testDir, `traces-${oldDate}.jsonl`), '{}');
+            fs.writeFileSync(path.join(testDir, `traces-${oldDate}.json`), '{}');
+            fs.writeFileSync(path.join(testDir, `traces-${oldDate}.txt`), 'text');
+            const result = cleanupOldFiles(testDir, 7);
+            assert.strictEqual(result.deleted, 1);
+            // Only .jsonl file should be deleted
+            assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${oldDate}.jsonl`)), false);
+            assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${oldDate}.json`)), true);
+            assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${oldDate}.txt`)), true);
+        });
+        it('should respect custom retention period', () => {
+            const today = new Date();
+            // Create file from 5 days ago
+            const fiveDaysAgo = new Date(today.getTime() - 5 * 24 * 60 * 60 * 1000);
+            const fiveDaysAgoStr = fiveDaysAgo.toISOString().split('T')[0];
+            fs.writeFileSync(path.join(testDir, `traces-${fiveDaysAgoStr}.jsonl`), '{}');
+            // With 7 day retention, file should be kept
+            let result = cleanupOldFiles(testDir, 7);
+            assert.strictEqual(result.deleted, 0);
+            assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${fiveDaysAgoStr}.jsonl`)), true);
+            // With 3 day retention, file should be deleted
+            result = cleanupOldFiles(testDir, 3);
+            assert.strictEqual(result.deleted, 1);
+            assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${fiveDaysAgoStr}.jsonl`)), false);
+        });
+        it('should handle empty directory', () => {
+            const result = cleanupOldFiles(testDir, 7);
+            assert.strictEqual(result.deleted, 0);
+            assert.deepStrictEqual(result.errors, []);
+        });
+        it('should reject directories outside allowed paths', () => {
+            const outsideDir = fs.mkdtempSync(path.join(os.tmpdir(), 'outside-'));
+            try {
+                fs.writeFileSync(path.join(outsideDir, 'traces-2020-01-01.jsonl'), '{}');
+                const result = cleanupOldFiles(outsideDir, 7, [testDir]);
+                assert.strictEqual(result.deleted, 0);
+                assert.strictEqual(result.errors.length, 1);
+                assert(result.errors[0].includes('not within allowed paths'));
+                // File should still exist
+                assert.strictEqual(fs.existsSync(path.join(outsideDir, 'traces-2020-01-01.jsonl')), true);
+            }
+            finally {
+                fs.rmSync(outsideDir, { recursive: true, force: true });
+            }
+        });
+        it('should allow directories within allowed paths', () => {
+            const subDir = path.join(testDir, 'subdir');
+            fs.mkdirSync(subDir);
+            fs.writeFileSync(path.join(subDir, 'traces-2020-01-01.jsonl'), '{}');
+            const result = cleanupOldFiles(subDir, 7, [testDir]);
+            assert.strictEqual(result.deleted, 1);
+            assert.deepStrictEqual(result.errors, []);
+        });
+        it('should handle file types: traces, logs, metrics', () => {
+            const oldDate = '2020-01-01';
+            fs.writeFileSync(path.join(testDir, `traces-${oldDate}.jsonl`), '{}');
+            fs.writeFileSync(path.join(testDir, `logs-${oldDate}.jsonl`), '{}');
+            fs.writeFileSync(path.join(testDir, `metrics-${oldDate}.jsonl`), '{}');
+            const result = cleanupOldFiles(testDir, 7);
+            assert.strictEqual(result.deleted, 3);
+            assert.deepStrictEqual(result.errors, []);
+        });
+        it('should use default retention of 7 days', () => {
+            const today = new Date();
+            // Create file from 8 days ago
+            const eightDaysAgo = new Date(today.getTime() - 8 * 24 * 60 * 60 * 1000);
+            const eightDaysAgoStr = eightDaysAgo.toISOString().split('T')[0];
+            // Create file from 6 days ago
+            const sixDaysAgo = new Date(today.getTime() - 6 * 24 * 60 * 60 * 1000);
+            const sixDaysAgoStr = sixDaysAgo.toISOString().split('T')[0];
+            fs.writeFileSync(path.join(testDir, `traces-${eightDaysAgoStr}.jsonl`), '{}');
+            fs.writeFileSync(path.join(testDir, `traces-${sixDaysAgoStr}.jsonl`), '{}');
+            // Use default retention (7 days)
+            const result = cleanupOldFiles(testDir);
+            assert.strictEqual(result.deleted, 1);
+            assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${eightDaysAgoStr}.jsonl`)), false);
+            assert.strictEqual(fs.existsSync(path.join(testDir, `traces-${sixDaysAgoStr}.jsonl`)), true);
+        });
+    });
+});
+//# sourceMappingURL=file-utils.test.js.map