@gguf/coder 0.3.1 → 0.3.3

package/source/utils/logging/log-query/aggregation/facet-generator.spec.ts

@@ -1,159 +0,0 @@
-/**
- * Tests for facet generator
- */
-
-import test from 'ava';
-import {generateFacets} from './facet-generator.js';
-import type {LogEntry} from '../types.js';
-
-// Helper to create test log entry
-function createLogEntry(overrides: Partial<LogEntry> = {}): LogEntry {
-	return {
-		timestamp: new Date().toISOString(),
-		level: 'info',
-		message: 'Test message',
-		...overrides,
-	};
-}
-
-test('generateFacets: empty entries returns empty facets', t => {
-	const facets = generateFacets([]);
-
-	t.deepEqual(facets.levels, {});
-	t.deepEqual(facets.sources, {});
-	t.deepEqual(facets.tags, {});
-	t.deepEqual(facets.errorTypes, {});
-	t.deepEqual(facets.hours, {});
-});
-
-test('generateFacets: counts levels correctly', t => {
-	const entries = [
-		createLogEntry({level: 'error'}),
-		createLogEntry({level: 'error'}),
-		createLogEntry({level: 'warn'}),
-		createLogEntry({level: 'info'}),
-	];
-
-	const facets = generateFacets(entries);
-
-	t.is(facets.levels.error, 2);
-	t.is(facets.levels.warn, 1);
-	t.is(facets.levels.info, 1);
-});
-
-test('generateFacets: counts sources correctly', t => {
-	const entries = [
-		createLogEntry({source: 'api-server'}),
-		createLogEntry({source: 'api-server'}),
-		createLogEntry({source: 'db-server'}),
-		createLogEntry({}), // No source
-	];
-
-	const facets = generateFacets(entries);
-
-	t.is(facets.sources['api-server'], 2);
-	t.is(facets.sources['db-server'], 1);
-	t.is(Object.keys(facets.sources).length, 2);
-});
-
-test('generateFacets: counts tags correctly', t => {
-	const entries = [
-		createLogEntry({tags: ['auth', 'security']}),
-		createLogEntry({tags: ['auth']}),
-		createLogEntry({tags: ['performance']}),
-		createLogEntry({}), // No tags
-	];
-
-	const facets = generateFacets(entries);
-
-	t.is(facets.tags.auth, 2);
-	t.is(facets.tags.security, 1);
-	t.is(facets.tags.performance, 1);
-});
-
-test('generateFacets: counts error types correctly', t => {
-	const entries = [
-		createLogEntry({error: {type: 'ValidationError'}}),
-		createLogEntry({error: {type: 'ValidationError'}}),
-		createLogEntry({error: {type: 'TypeError'}}),
-		createLogEntry({}), // No error
-	];
-
-	const facets = generateFacets(entries);
-
-	t.is(facets.errorTypes.ValidationError, 2);
-	t.is(facets.errorTypes.TypeError, 1);
-	t.is(Object.keys(facets.errorTypes).length, 2);
-});
-
-test('generateFacets: counts hours correctly', t => {
-	const entries = [
-		createLogEntry({timestamp: '2025-01-15T10:30:00Z'}),
-		createLogEntry({timestamp: '2025-01-15T10:45:00Z'}),
-		createLogEntry({timestamp: '2025-01-15T11:00:00Z'}),
-		createLogEntry({timestamp: '2025-01-15T11:30:00Z'}),
-	];
-
-	const facets = generateFacets(entries);
-
-	t.is(facets.hours['2025-01-15T10'], 2);
-	t.is(facets.hours['2025-01-15T11'], 2);
-});
-
-test('generateFacets: handles multiple facets together', t => {
-	const entries = [
-		createLogEntry({
-			level: 'error',
-			source: 'api-server',
-			tags: ['critical', 'database'],
-			error: {type: 'ConnectionError'},
-			timestamp: '2025-01-15T14:00:00Z',
-		}),
-		createLogEntry({
-			level: 'error',
-			source: 'api-server',
-			tags: ['critical'],
-			error: {type: 'TimeoutError'},
-			timestamp: '2025-01-15T14:30:00Z',
-		}),
-	];
-
-	const facets = generateFacets(entries);
-
-	t.is(facets.levels.error, 2);
-	t.is(facets.sources['api-server'], 2);
-	t.is(facets.tags.critical, 2);
-	t.is(facets.tags.database, 1);
-	t.is(facets.errorTypes.ConnectionError, 1);
-	t.is(facets.errorTypes.TimeoutError, 1);
-	t.is(facets.hours['2025-01-15T14'], 2);
-});
-
-test('generateFacets: single entry with all fields', t => {
-	const entries = [
-		createLogEntry({
-			level: 'warn',
-			source: 'db-server',
-			tags: ['slow', 'query'],
-			error: {type: 'SlowQueryWarning'},
-			timestamp: '2025-01-15T09:00:00Z',
-		}),
-	];
-
-	const facets = generateFacets(entries);
-
-	t.is(facets.levels.warn, 1);
-	t.is(facets.sources['db-server'], 1);
-	t.is(facets.tags.slow, 1);
-	t.is(facets.tags.query, 1);
-	t.is(facets.errorTypes.SlowQueryWarning, 1);
-	t.is(facets.hours['2025-01-15T09'], 1);
-});
-
-test('generateFacets: handles duplicate tag in same entry', t => {
-	const entries = [createLogEntry({tags: ['test', 'test']})];
-
-	const facets = generateFacets(entries);
-
-	t.is(facets.tags.test, 2); // Should count both occurrences
-});

package/source/utils/logging/log-query/aggregation/facet-generator.ts

@@ -1,47 +0,0 @@
-/**
- * Facet generation for query results
- */
-
-import type {LogEntry} from '../types';
-
-/**
- * Generate facets (counts by category) for filtered log entries
- */
-export function generateFacets(entries: LogEntry[]) {
-	const facets = {
-		levels: {} as Record<string, number>,
-		sources: {} as Record<string, number>,
-		tags: {} as Record<string, number>,
-		errorTypes: {} as Record<string, number>,
-		hours: {} as Record<string, number>,
-	};
-
-	for (const entry of entries) {
-		// Level facet
-		facets.levels[entry.level] = (facets.levels[entry.level] || 0) + 1;
-
-		// Source facet
-		if (entry.source) {
-			facets.sources[entry.source] = (facets.sources[entry.source] || 0) + 1;
-		}
-
-		// Tags facet
-		if (entry.tags) {
-			for (const tag of entry.tags) {
-				facets.tags[tag] = (facets.tags[tag] || 0) + 1;
-			}
-		}
-
-		// Error type facet
-		if (entry.error?.type) {
-			facets.errorTypes[entry.error.type] =
-				(facets.errorTypes[entry.error.type] || 0) + 1;
-		}
-
-		// Hour facet
-		const hour = new Date(entry.timestamp).toISOString().substring(0, 13);
-		facets.hours[hour] = (facets.hours[hour] || 0) + 1;
-	}
-
-	return facets;
-}

package/source/utils/logging/log-query/index.ts

@@ -1,23 +0,0 @@
-/**
- * Log query interface for searching and analyzing log data
- * Provides powerful filtering, searching, and analytics capabilities
- */
-
-// Re-export types (may be used for type annotations)
-export type {
-	LogEntry,
-	LogQuery,
-	QueryResult,
-	AggregationOptions,
-	AggregationResult,
-} from './types';
-
-// Re-export global storage instance (used by logging system)
-export {globalLogStorage} from './storage/log-storage';
-
-/**
- * Internal exports - import directly from specific modules if needed:
- * - LogStorage: './storage/log-storage'
- * - LogQueryBuilder, createLogQuery: './query/query-builder'
- * - logQueries: './utils/helpers'
- */

package/source/utils/logging/log-query/query/filter-predicates.spec.ts

@@ -1,247 +0,0 @@
-/**
- * Tests for filter predicates
- */
-
-import test from 'ava';
-import {matchesQuery} from './filter-predicates.js';
-import type {LogEntry, LogQuery} from '../types.js';
-
-// Helper to create test log entry
-function createLogEntry(overrides: Partial<LogEntry> = {}): LogEntry {
-	return {
-		timestamp: '2025-01-01T12:00:00Z',
-		level: 'info',
-		message: 'Test message',
-		...overrides,
-	};
-}
-
-test('matchesQuery: empty query matches all entries', t => {
-	const entry = createLogEntry();
-	const query: LogQuery = {};
-
-	t.true(matchesQuery(entry, query));
-});
-
-test('matchesQuery: time range - startTime filter', t => {
-	const entry = createLogEntry({timestamp: '2025-01-02T00:00:00Z'});
-
-	t.true(matchesQuery(entry, {startTime: new Date('2025-01-01T00:00:00Z')}));
-	t.false(matchesQuery(entry, {startTime: new Date('2025-01-03T00:00:00Z')}));
-});
-
-test('matchesQuery: time range - endTime filter', t => {
-	const entry = createLogEntry({timestamp: '2025-01-02T00:00:00Z'});
-
-	t.true(matchesQuery(entry, {endTime: new Date('2025-01-03T00:00:00Z')}));
-	t.false(matchesQuery(entry, {endTime: new Date('2025-01-01T00:00:00Z')}));
-});
-
-test('matchesQuery: level filter - includes', t => {
-	const entry = createLogEntry({level: 'error'});
-
-	t.true(matchesQuery(entry, {levels: ['error', 'warn']}));
-	t.false(matchesQuery(entry, {levels: ['info', 'debug']}));
-});
-
-test('matchesQuery: level filter - excludes', t => {
-	const entry = createLogEntry({level: 'info'});
-
-	t.false(matchesQuery(entry, {excludeLevels: ['info', 'debug']}));
-	t.true(matchesQuery(entry, {excludeLevels: ['error', 'warn']}));
-});
-
-test('matchesQuery: message contains', t => {
-	const entry = createLogEntry({message: 'User login successful'});
-
-	t.true(matchesQuery(entry, {messageContains: 'login'}));
-	t.false(matchesQuery(entry, {messageContains: 'logout'}));
-});
-
-test('matchesQuery: message regex', t => {
-	const entry = createLogEntry({message: 'Error: File not found'});
-
-	t.true(matchesQuery(entry, {messageRegex: /Error:.*/}));
-	t.false(matchesQuery(entry, {messageRegex: /Warning:.*/}));
-});
-
-test('matchesQuery: message starts with', t => {
-	const entry = createLogEntry({message: 'Starting application'});
-
-	t.true(matchesQuery(entry, {messageStartsWith: 'Starting'}));
-	t.false(matchesQuery(entry, {messageStartsWith: 'Stopping'}));
-});
-
-test('matchesQuery: message ends with', t => {
-	const entry = createLogEntry({message: 'Process completed successfully'});
-
-	t.true(matchesQuery(entry, {messageEndsWith: 'successfully'}));
-	t.false(matchesQuery(entry, {messageEndsWith: 'failed'}));
-});
-
-test('matchesQuery: correlation ID filter', t => {
-	const entry = createLogEntry({correlationId: 'corr-123'});
-
-	t.true(matchesQuery(entry, {correlationIds: ['corr-123', 'corr-456']}));
-	t.false(matchesQuery(entry, {correlationIds: ['corr-456', 'corr-789']}));
-});
-
-test('matchesQuery: correlation ID filter - missing correlationId', t => {
-	const entry = createLogEntry({}); // No correlationId
-
-	t.false(matchesQuery(entry, {correlationIds: ['corr-123']}));
-});
-
-test('matchesQuery: source filter', t => {
-	const entry = createLogEntry({source: 'api-server'});
-
-	t.true(matchesQuery(entry, {sources: ['api-server', 'db-server']}));
-	t.false(matchesQuery(entry, {sources: ['db-server', 'cache-server']}));
-});
-
-test('matchesQuery: exclude sources filter', t => {
-	const entry = createLogEntry({source: 'api-server'});
-
-	t.false(matchesQuery(entry, {excludeSources: ['api-server']}));
-	t.true(matchesQuery(entry, {excludeSources: ['db-server']}));
-});
-
-test('matchesQuery: tags filter', t => {
-	const entry = createLogEntry({tags: ['auth', 'security']});
-
-	t.true(matchesQuery(entry, {tags: ['auth']}));
-	t.true(matchesQuery(entry, {tags: ['security']}));
-	t.false(matchesQuery(entry, {tags: ['performance']}));
-});
-
-test('matchesQuery: hasTags filter', t => {
-	const entryWithTags = createLogEntry({tags: ['test']});
-	const entryWithoutTags = createLogEntry({});
-
-	t.true(matchesQuery(entryWithTags, {hasTags: true}));
-	t.false(matchesQuery(entryWithoutTags, {hasTags: true}));
-});
-
-test('matchesQuery: exclude tags filter', t => {
-	const entry = createLogEntry({tags: ['auth', 'security']});
-
-	t.true(matchesQuery(entry, {excludeTags: ['performance']}));
-	t.false(matchesQuery(entry, {excludeTags: ['auth']}));
-});
-
-test('matchesQuery: metadata key exists', t => {
-	const entry = createLogEntry({metadata: {userId: '123'}});
-
-	t.true(matchesQuery(entry, {metadataKey: 'userId'}));
-	t.false(matchesQuery(entry, {metadataKey: 'requestId'}));
-});
-
-test('matchesQuery: metadata value matches', t => {
-	const entry = createLogEntry({metadata: {status: 'active'}});
-
-	t.true(matchesQuery(entry, {metadataKey: 'status', metadataValue: 'active'}));
-	t.false(
-		matchesQuery(entry, {metadataKey: 'status', metadataValue: 'inactive'}),
-	);
-});
-
-test('matchesQuery: metadata exists filter', t => {
-	const entry = createLogEntry({metadata: {userId: '123'}});
-
-	t.true(matchesQuery(entry, {metadataExists: 'userId'}));
-	t.false(matchesQuery(entry, {metadataExists: 'requestId'}));
-});
-
-test('matchesQuery: duration min filter', t => {
-	const entry = createLogEntry({performance: {duration: 1500}});
-
-	t.true(matchesQuery(entry, {durationMin: 1000}));
-	t.false(matchesQuery(entry, {durationMin: 2000}));
-});
-
-test('matchesQuery: duration max filter', t => {
-	const entry = createLogEntry({performance: {duration: 1500}});
-
-	t.true(matchesQuery(entry, {durationMax: 2000}));
-	t.false(matchesQuery(entry, {durationMax: 1000}));
-});
-
-test('matchesQuery: memory threshold filter', t => {
-	const entry = createLogEntry({
-		performance: {memory: {heapUsed: 50000000}},
-	});
-
-	// memoryThreshold acts as minimum - entries below threshold are filtered out
-	t.true(matchesQuery(entry, {memoryThreshold: 30000000})); // 50MB >= 30MB
-	t.false(matchesQuery(entry, {memoryThreshold: 100000000})); // 50MB < 100MB
-});
-
-test('matchesQuery: has errors filter', t => {
-	const entryWithError = createLogEntry({error: {message: 'Error occurred'}});
-	const entryWithoutError = createLogEntry({});
-
-	t.true(matchesQuery(entryWithError, {hasErrors: true}));
-	t.false(matchesQuery(entryWithoutError, {hasErrors: true}));
-	t.true(matchesQuery(entryWithoutError, {hasErrors: false}));
-});
-
-test('matchesQuery: error types filter', t => {
-	const entry = createLogEntry({error: {type: 'ValidationError'}});
-
-	t.true(matchesQuery(entry, {errorTypes: ['ValidationError', 'TypeError']}));
-	t.false(matchesQuery(entry, {errorTypes: ['ReferenceError']}));
-});
-
-test('matchesQuery: request methods filter', t => {
-	const entry = createLogEntry({request: {method: 'POST'}});
-
-	t.true(matchesQuery(entry, {requestMethods: ['POST', 'PUT']}));
-	t.false(matchesQuery(entry, {requestMethods: ['GET', 'DELETE']}));
-});
-
-test('matchesQuery: request status codes filter', t => {
-	const entry = createLogEntry({request: {statusCode: 404}});
-
-	t.true(matchesQuery(entry, {requestStatusCodes: [404, 500]}));
-	t.false(matchesQuery(entry, {requestStatusCodes: [200, 201]}));
-});
-
-test('matchesQuery: request duration min filter', t => {
-	const entry = createLogEntry({request: {duration: 1500}});
-
-	t.true(matchesQuery(entry, {requestDurationMin: 1000}));
-	t.false(matchesQuery(entry, {requestDurationMin: 2000}));
-});
-
-test('matchesQuery: request duration max filter', t => {
-	const entry = createLogEntry({request: {duration: 1500}});
-
-	t.true(matchesQuery(entry, {requestDurationMax: 2000}));
-	t.false(matchesQuery(entry, {requestDurationMax: 1000}));
-});
-
-test('matchesQuery: multiple filters combined', t => {
-	const entry = createLogEntry({
-		level: 'error',
-		message: 'Database connection failed',
-		source: 'db-server',
-		tags: ['database', 'critical'],
-	});
-
-	t.true(
-		matchesQuery(entry, {
-			levels: ['error'],
-			messageContains: 'Database',
-			sources: ['db-server'],
-			tags: ['database'],
-		}),
-	);
-
-	t.false(
-		matchesQuery(entry, {
-			levels: ['error'],
-			messageContains: 'API', // This doesn't match
-			sources: ['db-server'],
-		}),
-	);
-});

package/source/utils/logging/log-query/query/filter-predicates.ts

@@ -1,154 +0,0 @@
-/**
- * Filter predicates for matching log entries against queries
- */
-
-import type {LogEntry, LogQuery} from '../types';
-
-/**
- * Check if a log entry matches the given query filters
- */
-export function matchesQuery(entry: LogEntry, query: LogQuery): boolean {
-	// Time range filtering
-	if (query.startTime && new Date(entry.timestamp) < query.startTime)
-		return false;
-	if (query.endTime && new Date(entry.timestamp) > query.endTime) return false;
-
-	// Level filtering
-	if (query.levels && !query.levels.includes(entry.level)) return false;
-	if (query.excludeLevels && query.excludeLevels.includes(entry.level))
-		return false;
-
-	// Message filtering
-	if (query.messageContains && !entry.message.includes(query.messageContains))
-		return false;
-	if (query.messageRegex && !query.messageRegex.test(entry.message))
-		return false;
-	if (
-		query.messageStartsWith &&
-		!entry.message.startsWith(query.messageStartsWith)
-	)
-		return false;
-	if (query.messageEndsWith && !entry.message.endsWith(query.messageEndsWith))
-		return false;
-
-	// Correlation and request filtering
-	if (query.correlationIds) {
-		if (!entry.correlationId) return false;
-		if (!query.correlationIds.includes(entry.correlationId)) return false;
-	}
-	if (
-		query.requestIds &&
-		entry.requestId &&
-		!query.requestIds.includes(entry.requestId)
-	)
-		return false;
-	if (query.userIds && entry.userId && !query.userIds.includes(entry.userId))
-		return false;
-	if (
-		query.sessionIds &&
-		entry.sessionId &&
-		!query.sessionIds.includes(entry.sessionId)
-	)
-		return false;
-
-	// Source filtering
-	if (query.sources) {
-		if (!entry.source) return false;
-		if (!query.sources.includes(entry.source)) return false;
-	}
-	if (
-		query.excludeSources &&
-		entry.source &&
-		query.excludeSources.includes(entry.source)
-	)
-		return false;
-
-	// Tag filtering
-	if (query.hasTags && (!entry.tags || entry.tags.length === 0)) return false;
-	if (query.tags && entry.tags) {
-		const hasAnyTag = query.tags.some(tag => entry.tags?.includes(tag));
-		if (!hasAnyTag) return false;
-	}
-	if (query.excludeTags && entry.tags) {
-		const hasExcludedTag = query.excludeTags.some(tag =>
-			entry.tags?.includes(tag),
-		);
-		if (hasExcludedTag) return false;
-	}
-
-	// Metadata filtering
-	if (
-		query.metadataKey &&
-		(!entry.metadata || !(query.metadataKey in entry.metadata))
-	)
-		return false;
-	if (query.metadataKey && query.metadataValue !== undefined) {
-		if (entry.metadata?.[query.metadataKey] !== query.metadataValue)
-			return false;
-	}
-	if (
-		query.metadataExists &&
-		(!entry.metadata || !(query.metadataExists in entry.metadata))
-	)
-		return false;
-
-	// Performance filtering
-	if (
-		query.durationMin &&
-		entry.performance?.duration &&
-		entry.performance.duration < query.durationMin
-	)
-		return false;
-	if (
-		query.durationMax &&
-		entry.performance?.duration &&
-		entry.performance.duration > query.durationMax
-	)
-		return false;
-	if (
-		query.memoryThreshold &&
-		entry.performance?.memory?.heapUsed &&
-		entry.performance.memory.heapUsed < query.memoryThreshold
-	)
-		return false;
-
-	// Error filtering
-	if (query.hasErrors !== undefined) {
-		const hasError = !!entry.error;
-		if (hasError !== query.hasErrors) return false;
-	}
-	if (
-		query.errorTypes &&
-		entry.error &&
-		!query.errorTypes.includes(entry.error.type || '')
-	)
-		return false;
-
-	// Request filtering
-	if (
-		query.requestMethods &&
-		entry.request?.method &&
-		!query.requestMethods.includes(entry.request.method)
-	)
-		return false;
-	if (
-		query.requestStatusCodes &&
-		entry.request?.statusCode &&
-		!query.requestStatusCodes.includes(entry.request.statusCode)
-	)
-		return false;
-	if (
-		query.requestDurationMin &&
-		entry.request?.duration &&
-		entry.request.duration < query.requestDurationMin
-	)
-		return false;
-	if (
-		query.requestDurationMax &&
-		entry.request?.duration &&
-		entry.request.duration > query.requestDurationMax
-	)
-		return false;
-
-	return true;
-}