@vibesdotdev/logging 0.0.1

package/src/sinks/memory/memory.impl.ts

@@ -0,0 +1,119 @@
+/**
+ * Memory Sink Implementation
+ *
+ * Stores log entries in memory for testing and inspection.
+ */
+
+import type { SinkImplementation, SinkContext } from '../../kinds/sink.ts';
+import type { SinkDescriptor } from '../../schemas/sink.ts';
+import type { RuntimeLogEntry, LogLevel } from '../../schemas/entry.ts';
+
+/** Query options for memory sink */
+export interface MemorySinkQueryOptions {
+	level?: LogLevel;
+	namespace?: string | RegExp;
+	message?: string | RegExp;
+	limit?: number;
+	since?: Date;
+}
+
+/**
+ * Memory sink - stores entries in-memory for testing.
+ */
+export default class MemorySink implements SinkImplementation {
+	readonly id: string;
+	readonly descriptor: SinkDescriptor;
+	private entries: RuntimeLogEntry[] = [];
+	private maxEntries: number = 10000;
+
+	constructor(descriptor: SinkDescriptor, _context: SinkContext) {
+		this.id = descriptor.id;
+		this.descriptor = descriptor;
+	}
+
+	emit(entry: RuntimeLogEntry): void {
+		this.entries.push(entry);
+
+		// Trim if over limit
+		if (this.entries.length > this.maxEntries) {
+			this.entries = this.entries.slice(-this.maxEntries);
+		}
+	}
+
+	async flush(): Promise<void> {
+		// Memory is synchronous
+	}
+
+	async close(): Promise<void> {
+		this.entries = [];
+	}
+
+	/**
+	 * Get all stored entries.
+	 */
+	getEntries(): RuntimeLogEntry[] {
+		return [...this.entries];
+	}
+
+	/**
+	 * Query entries with filters.
+	 */
+	query(options: MemorySinkQueryOptions = {}): RuntimeLogEntry[] {
+		let results = [...this.entries];
+
+		if (options.level) {
+			results = results.filter((e) => e.level === options.level);
+		}
+
+		if (options.namespace) {
+			const matcher =
+				typeof options.namespace === 'string'
+					? (ns: string) => ns === options.namespace || ns.startsWith(`${options.namespace}:`)
+					: (ns: string) => (options.namespace as RegExp).test(ns);
+			results = results.filter((e) => matcher(e.namespace));
+		}
+
+		if (options.message) {
+			const matcher =
+				typeof options.message === 'string'
+					? (msg: string) => msg.includes(options.message as string)
+					: (msg: string) => (options.message as RegExp).test(msg);
+			results = results.filter((e) => matcher(e.message));
+		}
+
+		if (options.since) {
+			const sinceTime = options.since.getTime();
+			results = results.filter((e) => new Date(e.timestamp).getTime() >= sinceTime);
+		}
+
+		if (options.limit) {
+			results = results.slice(-options.limit);
+		}
+
+		return results;
+	}
+
+	/**
+	 * Clear all entries.
+	 */
+	clear(): void {
+		this.entries = [];
+	}
+
+	/**
+	 * Set maximum entries to keep.
+	 */
+	setMaxEntries(max: number): void {
+		this.maxEntries = max;
+		if (this.entries.length > max) {
+			this.entries = this.entries.slice(-max);
+		}
+	}
+
+	/**
+	 * Get entry count.
+	 */
+	get count(): number {
+		return this.entries.length;
+	}
+}

package/src/sinks/stdout/stdout.descriptor.ts

@@ -0,0 +1,13 @@
+import type { SinkDescriptor } from '../../schemas/sink.ts';
+
+const descriptor: SinkDescriptor = {
+	kind: 'logging/sink',
+	id: 'stdout',
+	name: 'Stdout Sink',
+	description: 'Writes log entries to stderr (safe for MCP stdio mode)',
+	tags: ['cli', 'stderr'],
+	async: false,
+	formats: ['raw']
+};
+
+export default descriptor;

package/src/sinks/stdout/stdout.impl.cli.ts

@@ -0,0 +1,27 @@
+import type { SinkImplementation, SinkContext } from '../../kinds/sink.ts';
+import type { SinkDescriptor } from '../../schemas/sink.ts';
+import type { RuntimeLogEntry } from '../../schemas/entry.ts';
+
+function toOutputLine(entry: RuntimeLogEntry): string {
+	const rawLine = entry.context?.rawLine;
+	if (typeof rawLine === 'string') return rawLine;
+	const payload =
+		entry.context && Object.keys(entry.context).length > 0
+			? ` ${JSON.stringify(entry.context)}`
+			: '';
+	return `[${entry.level.toUpperCase()}] [${entry.namespace}] ${entry.message}${payload}\n`;
+}
+
+export default class StdoutSink implements SinkImplementation {
+	readonly id: string;
+	readonly descriptor: SinkDescriptor;
+
+	constructor(descriptor: SinkDescriptor, _context: SinkContext) {
+		this.id = descriptor.id;
+		this.descriptor = descriptor;
+	}
+
+	emit(entry: RuntimeLogEntry): void {
+		process.stderr.write(toOutputLine(entry));
+	}
+}

package/src/sinks.context.descriptor.ts

@@ -0,0 +1,10 @@
+/**
+ * Logging Sinks Context Descriptor
+ */
+
+import { createContextDescriptor } from '@vibesdotdev/runtime/factory/context';
+
+export default createContextDescriptor({
+	id: 'logging/sinks',
+	description: 'Map of resolved logging sink implementations by ID.'
+});

package/src/sinks.context.impl.ts

@@ -0,0 +1,30 @@
+/**
+ * Logging Sinks Context Implementation
+ */
+import type { SinkImplementation } from './kinds/sink.ts';
+
+export default {
+	provide: async (runtime: unknown) => {
+		const rt = runtime as {
+			hasKind(k: string): boolean;
+			query(k: string): {
+				descriptors(): { id: string }[];
+				withId(id: string): { resolve(): Promise<unknown> };
+			};
+		};
+		const map = new Map<string, SinkImplementation>();
+		if (rt.hasKind('logging/sink')) {
+			for (const desc of rt.query('logging/sink').descriptors()) {
+				try {
+					map.set(
+						desc.id,
+						(await rt.query('logging/sink').withId(desc.id).resolve()) as SinkImplementation
+					);
+				} catch {
+					// Skip sinks that fail to resolve
+				}
+			}
+		}
+		return map;
+	}
+};