@vibesdotdev/logging 0.0.1 → 1.0.0-rc.4

package/src/cli/logs.view.impl.ts

@@ -1,108 +0,0 @@
-/**
- * Logs View CLI Command Implementation
- *
- * View log entries from an output.
- */
-
-import { getVibesRuntime } from '@vibesdotdev/runtime';
-import type { OutputDescriptor } from '../schemas/output.ts';
-import type { OutputImplementation } from '../kinds/output.ts';
-
-interface ViewArgs {
-	output?: string;
-}
-
-interface ViewOptions {
-	lines?: string;
-	offset?: string;
-	filter?: string;
-	ignoreCase?: boolean;
-	json?: boolean;
-	raw?: boolean;
-}
-
-// Color codes for log levels
-const LEVEL_COLORS: Record<string, string> = {
-	debug: '\x1b[90m', // gray
-	info: '\x1b[36m', // cyan
-	warn: '\x1b[33m', // yellow
-	error: '\x1b[31m' // red
-};
-const RESET = '\x1b[0m';
-
-function formatLine(line: string, raw: boolean): string {
-	if (raw) return line;
-
-	try {
-		const entry = JSON.parse(line);
-		const level = entry.level ?? 'info';
-		const color = LEVEL_COLORS[level] ?? '';
-		const timestamp = entry.timestamp?.slice(0, 19) ?? '';
-		const namespace = entry.namespace ?? '';
-		const message = entry.message ?? '';
-		const context = entry.context ? ` ${JSON.stringify(entry.context)}` : '';
-
-		return `${color}[${timestamp}] [${level.toUpperCase().padEnd(5)}] [${namespace}]${RESET} ${message}${context}`;
-	} catch {
-		return line;
-	}
-}
-
-export default {
-	async execute(args: ViewArgs, opts: ViewOptions): Promise<void> {
-		const runtime = getVibesRuntime();
-		const outputId = args.output ?? 'file';
-
-		let output: OutputImplementation;
-		try {
-			output = await runtime
-				.query<OutputDescriptor, OutputImplementation>('logging/output')
-				.withId(outputId)
-				.resolve();
-		} catch (err) {
-			console.error(
-				`Failed to resolve output '${outputId}': ${err instanceof Error ? err.message : String(err)}`
-			);
-			process.exit(1);
-		}
-
-		const lines = opts.lines ? parseInt(opts.lines, 10) : 50;
-		const offset = opts.offset ? parseInt(opts.offset, 10) : 0;
-
-		let entries: string[];
-		try {
-			entries = await output.read({
-				lines,
-				offset,
-				filter: opts.filter,
-				ignoreCase: opts.ignoreCase
-			});
-		} catch (err) {
-			console.error(`Failed to read: ${err instanceof Error ? err.message : String(err)}`);
-			process.exit(1);
-		}
-
-		if (entries.length === 0) {
-			console.log('No log entries found.');
-			return;
-		}
-
-		if (opts.json) {
-			const parsed = entries.map((line) => {
-				try {
-					return JSON.parse(line);
-				} catch {
-					return { raw: line };
-				}
-			});
-			console.log(JSON.stringify(parsed, null, 2));
-			return;
-		}
-
-		console.log(`\n📜 ${outputId} (${entries.length} entries)\n`);
-		for (const entry of entries) {
-			console.log(formatLine(entry, opts.raw ?? false));
-		}
-		console.log('');
-	}
-};

package/src/cli/types.ts

@@ -1,59 +0,0 @@
-/**
- * CLI Descriptor Types (local definitions)
- *
- * These types are defined locally because the CLI module hasn't been
- * migrated to the monorepo yet. They mirror the shapes from the CLI
- * module's descriptor schemas.
- */
-
-import type { RuntimeDescriptor } from '@vibesdotdev/runtime/schemas/descriptor';
-
-export interface CLIGroupAssetDescriptor extends RuntimeDescriptor {
-	kind: 'cli/group';
-	name: string;
-	description: string;
-	parent?: string;
-	aliases?: string[];
-	surfaces?: ('cli' | 'web' | 'worker' | 'bridge')[];
-	internal?: boolean;
-	order?: number;
-	logBuffer?: {
-		enabled?: boolean;
-		sinks?: string[];
-		fallbackToStdout?: boolean;
-	};
-}
-
-export interface CLICommandAssetDescriptor extends RuntimeDescriptor {
-	kind: 'cli/command';
-	name: string;
-	description: string;
-	group: string;
-	arguments?: {
-		name: string;
-		description: string;
-		required?: boolean;
-		variadic?: boolean;
-		default?: unknown;
-	}[];
-	options?: {
-		flags: string;
-		description: string;
-		default?: unknown;
-		choices?: string[];
-	}[];
-	aliases?: string[];
-	surfaces?: ('cli' | 'web' | 'worker' | 'bridge')[];
-	internal?: boolean;
-	examples?: {
-		command: string;
-		description: string;
-	}[];
-	order?: number;
-	tuiAppId?: string;
-	logBuffer?: {
-		enabled?: boolean;
-		sinks?: string[];
-		fallbackToStdout?: boolean;
-	};
-}

package/src/contexts/audit.ts

@@ -1,36 +0,0 @@
-/**
- * Audit Logger Context Types
- *
- * Consumers should use the runtime to query for audit implementations:
- *
- * ```ts
- * const runtime = getVibesRuntime();
- * const auditor = await runtime.query('logging/audit').withId('default').resolve();
- * await auditor.log({ category: 'authorization', ... });
- * ```
- */
-
-import type { AuditImplementation, AuditLogInput, AuditQueryOptions } from '../kinds/audit.ts';
-import type { AuditEntry, AuditCategory } from '../schemas/audit.ts';
-
-/**
- * Audit context configuration.
- */
-export interface AuditContextConfig {
-	/** Workspace path for audit log storage */
-	workspacePath: string;
-	/** Default category for uncategorized events */
-	defaultCategory: AuditCategory;
-}
-
-/**
- * Audit context provider interface.
- */
-export interface AuditContextProvider {
-	/** Log an audit event */
-	log(input: AuditLogInput): Promise<AuditEntry>;
-	/** Query audit entries */
-	query(options?: AuditQueryOptions): Promise<AuditEntry[]>;
-	/** Get auditor for a specific category */
-	forCategory(category: AuditCategory): Promise<AuditImplementation>;
-}

package/src/contexts/fallback-logger.ts

@@ -1,80 +0,0 @@
-import type { LoggerImplementation } from '../kinds/logger.impl';
-import type { LogLevel, LogContext, LoggerChildOptions, PerformanceTrackerParams } from '../schemas/entry.ts';
-import type { PerformanceTracker } from '../schemas/entry.ts';
-
-function createFallbackLoggerInternal(
-	namespace: string,
-	baseContext: LogContext
-): LoggerImplementation {
-	const normalizeLogContext = (context: unknown): LogContext => {
-		if (context === undefined || context === null) {
-			return {};
-		}
-		if (context instanceof Error) {
-			return {
-				errorName: context.name,
-				errorMessage: context.message,
-				stack: context.stack
-			};
-		}
-		if (typeof context === 'object' && !Array.isArray(context)) {
-			return context as LogContext;
-		}
-		return { value: context };
-	};
-
-	const emit = (level: LogLevel, message: string, context?: unknown) => {
-		if (level === 'debug') return;
-		const prefix = `[${namespace}]`;
-		const merged = { ...baseContext, ...normalizeLogContext(context) };
-		const payloadStr =
-			Object.keys(merged).length > 0 ? ` ${JSON.stringify(merged)}` : '';
-		const line = `${prefix} ${message}${payloadStr}`;
-		console.error(line);
-	};
-
-	return {
-		namespace,
-		fullNamespace: namespace,
-		debug: (msg, ctx) => emit('debug', msg, ctx),
-		info: (msg, ctx) => emit('info', msg, ctx),
-		warn: (msg, ctx) => emit('warn', msg, ctx),
-		error: (msg, ctx) => emit('error', msg, ctx),
-		child: (options: LoggerChildOptions) => {
-			const childNs =
-				typeof options === 'string'
-					? `${namespace}:${options}`
-					: `${namespace}:${options.namespace ?? options.context ?? ''}`;
-			return createFallbackLoggerInternal(childNs, baseContext);
-		},
-		withContext: (ctx: LogContext) =>
-			createFallbackLoggerInternal(namespace, { ...baseContext, ...ctx }),
-		withRequestContext: (ctx) =>
-			createFallbackLoggerInternal(namespace, { ...baseContext, ...ctx }),
-		withJobContext: (ctx) =>
-			createFallbackLoggerInternal(namespace, { ...baseContext, ...ctx }),
-		performanceTracker: (params: PerformanceTrackerParams): PerformanceTracker => {
-			let startTime = 0;
-			const tracker = createFallbackLoggerInternal(namespace, {
-				...baseContext,
-				operation: params.operation,
-				...params.metadata
-			});
-			return {
-				start() { startTime = Date.now(); tracker.debug(`operation.${params.operation}.start`); },
-				end(successContext?: LogContext) {
-					const duration = Date.now() - startTime;
-					tracker.info(`operation.${params.operation}.success`, { duration, ...successContext });
-				},
-				fail(error: unknown, errorContext?: LogContext) {
-					const duration = Date.now() - startTime;
-					tracker.error(`operation.${params.operation}.failure`, { duration, error, ...errorContext });
-				}
-			};
-		}
-	};
-}
-
-export function createFallbackLogger(namespace: string): LoggerImplementation {
-	return createFallbackLoggerInternal(namespace, {});
-}

package/src/contexts/index.ts

@@ -1,23 +0,0 @@
-/**
- * Logging Contexts
- *
- * Context providers for dependency injection.
- */
-
-export {
-	configureLoggerContext,
-	getLoggerContextConfig,
-	createLoggerContextProvider,
-	getLoggerContext,
-	setLoggerContext,
-	getLogger,
-	getDefaultLogger,
-	registerLogger,
-	initializeLoggers,
-	type LoggerContextConfig,
-	type LoggerContextProvider,
-	type RuntimeLogger
-} from './logger.ts';
-
-// Audit context types only — use runtime to resolve audit implementations
-export { type AuditContextConfig, type AuditContextProvider } from './audit.ts';

package/src/contexts/logger.ts

@@ -1,119 +0,0 @@
-/**
- * Logger Context Provider
- *
- * Provides logger instances to runtime assets via context injection.
- * Loggers are resolved from the runtime and cached for sync access.
- */
-
-import type { LoggerImplementation } from '../kinds/logger.impl';
-import { createFallbackLogger } from './fallback-logger.ts';
-
-export type RuntimeLogger = LoggerImplementation;
-
-export interface LoggerContextConfig {
-	defaultNamespace: string;
-	defaultRuntime: 'server' | 'cli' | 'worker' | 'browser' | 'mcp';
-}
-
-const defaultConfig: LoggerContextConfig = {
-	defaultNamespace: 'vibes',
-	defaultRuntime: 'server'
-};
-
-let activeConfig = { ...defaultConfig };
-
-export function configureLoggerContext(config: Partial<LoggerContextConfig>): void {
-	activeConfig = { ...activeConfig, ...config };
-}
-
-export function getLoggerContextConfig(): LoggerContextConfig {
-	return { ...activeConfig };
-}
-
-const loggerCache = new Map<string, LoggerImplementation>();
-
-export function registerLogger(id: string, logger: LoggerImplementation): void {
-	loggerCache.set(id, logger);
-}
-
-export async function initializeLoggers(): Promise<void> {
-	try {
-		const { getVibesRuntime } = await import('@vibesdotdev/runtime');
-		const runtime = getVibesRuntime();
-		const loggerIds = runtime.query('logging/logger').ids();
-		const errors: Array<{ id: string; error: unknown }> = [];
-
-		for (const id of loggerIds) {
-			try {
-				const logger = (await runtime.query('logging/logger').withId(id).resolve()) as LoggerImplementation;
-				loggerCache.set(id, logger);
-			} catch (error) {
-				// Collect errors for reporting but continue initializing other loggers
-				errors.push({ id, error });
-			}
-		}
-
-		// Log summary of initialization results
-		if (errors.length > 0) {
-			const fallbackLogger = createFallbackLogger('logging');
-			fallbackLogger.warn(`Failed to initialize ${errors.length} logger(s):`, {
-				loggerIds: errors.map((e) => e.id),
-				errors: errors.map((e) =>
-					e.error instanceof Error ? e.error.message : String(e.error)
-				)
-			});
-		}
-	} catch (error) {
-		// Runtime not available - this is expected in some contexts, use fallback
-		const fallbackLogger = createFallbackLogger('logging');
-		fallbackLogger.debug('Runtime not available for logger initialization, using fallback loggers', {
-			error: error instanceof Error ? error.message : String(error)
-		});
-	}
-}
-
-export interface LoggerContextProvider {
-	getLogger(id: string): LoggerImplementation;
-	getDefaultLogger(): LoggerImplementation;
-}
-
-export function createLoggerContextProvider(
-	config?: Partial<LoggerContextConfig>
-): LoggerContextProvider {
-	const mergedConfig = { ...activeConfig, ...config };
-
-	return {
-		getLogger(id: string): LoggerImplementation {
-			let logger = loggerCache.get(id);
-			if (logger) return logger;
-			logger = createFallbackLogger(id);
-			loggerCache.set(id, logger);
-			return logger;
-		},
-
-		getDefaultLogger(): LoggerImplementation {
-			return this.getLogger(mergedConfig.defaultNamespace);
-		}
-	};
-}
-
-let globalLoggerContext: LoggerContextProvider | null = null;
-
-export function getLoggerContext(): LoggerContextProvider {
-	if (!globalLoggerContext) {
-		globalLoggerContext = createLoggerContextProvider();
-	}
-	return globalLoggerContext;
-}
-
-export function setLoggerContext(provider: LoggerContextProvider): void {
-	globalLoggerContext = provider;
-}
-
-export function getLogger(id: string): LoggerImplementation {
-	return getLoggerContext().getLogger(id);
-}
-
-export function getDefaultLogger(): LoggerImplementation {
-	return getLoggerContext().getDefaultLogger();
-}

package/src/core/index.ts

@@ -1,32 +0,0 @@
-/**
- * Core Logging
- *
- * Exports logger factory and types.
- */
-
-// Logger factory
-export { createRuntimeLogger } from './logger.ts';
-
-// Types
-export type {
-	Logger,
-	RuntimeLogger,
-	Runtime,
-	RuntimeLoggerOptions,
-	RuntimeLoggerConfig
-} from './types.ts';
-
-// Namespace utilities
-export {
-	parseNamespaceSettings,
-	parseNamespaceSettingsFromEnv,
-	matchesSelector,
-	isNamespaceIncluded,
-	shouldLog,
-	updateNamespaceSettings,
-	getNamespaceSettings,
-	defaultNamespaceSettings,
-	type NamespaceSelector,
-	type NamespaceSelectors,
-	type NamespaceSettings
-} from './namespace.ts';

package/src/core/logger.ts

@@ -1,150 +0,0 @@
-import type { SinkImplementation } from '../kinds/sink.ts';
-import type { RuntimeLogger, RuntimeLoggerOptions, RuntimeLoggerConfig } from './types.ts';
-import type {
-	LogLevel,
-	LogContext,
-	RuntimeLogEntry,
-	LoggerChildOptions,
-	RequestLogContext,
-	JobLogContext,
-	PerformanceTracker,
-	PerformanceTrackerParams
-} from '../schemas/entry.ts';
-import { shouldLog, getNamespaceSettings, type NamespaceSettings } from './namespace.ts';
-import {
-	createDefaultConsoleSink,
-	deriveChildConfig
-} from '../kinds/logger.utils';
-
-const defaultSink = createDefaultConsoleSink();
-
-function normalizeLogContext(context: unknown): LogContext {
-	if (context === undefined || context === null) {
-		return {};
-	}
-	if (context instanceof Error) {
-		return {
-			errorName: context.name,
-			errorMessage: context.message,
-			stack: context.stack
-		};
-	}
-	if (typeof context === 'object' && !Array.isArray(context)) {
-		return context as LogContext;
-	}
-	return { value: context };
-}
-
-export function createRuntimeLogger(options: RuntimeLoggerOptions): RuntimeLogger {
-	const sinks: SinkImplementation[] = options.sinkImpls ?? [defaultSink];
-
-	const config: RuntimeLoggerConfig = {
-		namespace: options.namespace,
-		fullNamespace: options.namespace,
-		runtime: options.runtime ?? 'server',
-		staticMetadata: { runtime: options.runtime ?? 'server', ...options.staticMetadata },
-		sinkIds: options.sinks ?? ['console']
-	};
-
-	const getLevelSettings = (): NamespaceSettings => {
-		const base = getNamespaceSettings();
-		if (options.level && base.defaultLevel !== options.level) {
-			return { ...base, defaultLevel: options.level };
-		}
-		return base;
-	};
-
-	const emitEntry = (level: LogLevel, message: string, ctx?: unknown, fullNs?: string): void => {
-		const ns = fullNs ?? config.namespace;
-		if (!shouldLog({ namespace: ns, level, settings: getLevelSettings() })) return;
-		const entry: RuntimeLogEntry = {
-			timestamp: new Date().toISOString(),
-			level,
-			namespace: ns,
-			message,
-			context: { ...config.staticMetadata, ...normalizeLogContext(ctx) }
-		};
-		for (const sink of sinks) {
-			try { sink.emit(entry); } catch { defaultSink.emit(entry); }
-		}
-	};
-
-	const buildLogger = (metadata: LogContext, fullNamespace: string): RuntimeLogger => {
-		const log = (level: LogLevel, message: string, ctx?: unknown) =>
-			emitEntry(
-				level,
-				message,
-				{ ...metadata, ...normalizeLogContext(ctx) },
-				fullNamespace
-			);
-
-		return {
-			namespace: config.namespace,
-			fullNamespace,
-
-			debug(message, ctx) { log('debug', message, ctx); },
-			info(message, ctx) { log('info', message, ctx); },
-			warn(message, ctx) { log('warn', message, ctx); },
-			error(message, ctx) { log('error', message, ctx); },
-
-			child(childOptions: LoggerChildOptions): RuntimeLogger {
-				const { nextNamespace, childMetadata } = deriveChildConfig(fullNamespace, childOptions);
-				return buildLogger({ ...metadata, ...childMetadata }, nextNamespace);
-			},
-
-			withContext(context: LogContext): RuntimeLogger {
-				return buildLogger({ ...metadata, ...context }, fullNamespace);
-			},
-
-			withRequestContext(context: RequestLogContext): RuntimeLogger {
-				const m = metadata;
-				return buildLogger({
-					...m,
-					requestId: context.requestId ?? m.requestId,
-					correlationId: context.correlationId ?? m.correlationId,
-					sessionId: context.sessionId ?? m.sessionId,
-					userId: context.userId ?? m.userId,
-					userAgent: context.userAgent ?? m.userAgent,
-					ip: context.ip ?? m.ip,
-					route: context.route ?? m.route,
-					method: context.method ?? m.method
-				}, fullNamespace);
-			},
-
-			withJobContext(context: JobLogContext): RuntimeLogger {
-				const m = metadata;
-				return buildLogger({
-					...m,
-					jobId: context.jobId ?? m.jobId,
-					queueId: context.queueId ?? m.queueId,
-					queueName: context.queueName ?? m.queueName,
-					toolId: context.toolId ?? m.toolId,
-					parentJobId: context.parentJobId ?? m.parentJobId,
-					attempt: context.attempt ?? m.attempt,
-					maxAttempts: context.maxAttempts ?? m.maxAttempts
-				}, fullNamespace);
-			},
-
-			performanceTracker(params: PerformanceTrackerParams): PerformanceTracker {
-				let startTime = 0;
-				const tracker = buildLogger(
-					{ ...metadata, operation: params.operation, ...params.metadata },
-					fullNamespace
-				);
-				return {
-					start() { startTime = Date.now(); tracker.debug(`operation.${params.operation}.start`); },
-					end(successContext?: LogContext) {
-						const duration = Date.now() - startTime;
-						tracker.info(`operation.${params.operation}.success`, { duration, ...successContext });
-					},
-					fail(error: unknown, errorContext?: LogContext) {
-						const duration = Date.now() - startTime;
-						tracker.error(`operation.${params.operation}.failure`, { duration, error, ...errorContext });
-					}
-				};
-			}
-		};
-	};
-
-	return buildLogger(options.staticMetadata ?? {}, config.namespace);
-}