@vibesdotdev/logging 0.0.1

package/src/cli/logs.search.descriptor.ts

@@ -0,0 +1,61 @@
+/**
+ * Logs Search CLI Command Descriptor
+ *
+ * Search log entries by pattern.
+ */
+
+import type { CLICommandAssetDescriptor } from './types.ts';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'logs.search',
+	name: 'search',
+	description: 'Search log entries by pattern',
+	group: 'logs',
+
+	arguments: [
+		{
+			name: 'pattern',
+			description: 'Search pattern (regex supported)',
+			required: true
+		}
+	],
+
+	options: [
+		{
+			flags: '-o, --output <id>',
+			description: 'Search in specific output (default: all)'
+		},
+		{
+			flags: '-n, --max <count>',
+			description: 'Maximum results to return',
+			default: '100'
+		},
+		{
+			flags: '-i, --ignore-case',
+			description: 'Case-insensitive search'
+		},
+		{
+			flags: '--level <level>',
+			description: 'Filter by log level'
+		},
+		{
+			flags: '--since <time>',
+			description: 'Only show entries since (e.g., 1h, 30m, 2024-01-01)'
+		},
+		{
+			flags: '--json',
+			description: 'Output as JSON'
+		},
+		{
+			flags: '-C, --context <lines>',
+			description: 'Show context lines around matches'
+		}
+	],
+
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

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

@@ -0,0 +1,173 @@
+/**
+ * Logs Search CLI Command Implementation
+ *
+ * Search log entries by pattern.
+ */
+
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import type { OutputDescriptor } from '../schemas/output.ts';
+import type { OutputImplementation } from '../kinds/output.ts';
+
+interface SearchArgs {
+	pattern: string;
+}
+
+interface SearchOptions {
+	output?: string;
+	max?: string;
+	ignoreCase?: boolean;
+	level?: string;
+	since?: string;
+	json?: boolean;
+	context?: string;
+}
+
+// Color codes for log levels
+const LEVEL_COLORS: Record<string, string> = {
+	debug: '\x1b[90m',
+	info: '\x1b[36m',
+	warn: '\x1b[33m',
+	error: '\x1b[31m'
+};
+const RESET = '\x1b[0m';
+const HIGHLIGHT = '\x1b[43m\x1b[30m'; // Yellow background, black text
+
+function formatLine(line: string, pattern: RegExp): string {
+	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 ?? '';
+
+		// Highlight matches
+		const highlightedMessage = message.replace(
+			pattern,
+			(match: string) => `${HIGHLIGHT}${match}${RESET}`
+		);
+
+		return `${color}[${timestamp}] [${level.toUpperCase().padEnd(5)}] [${namespace}]${RESET} ${highlightedMessage}`;
+	} catch {
+		return line.replace(pattern, (match: string) => `${HIGHLIGHT}${match}${RESET}`);
+	}
+}
+
+function matchesLevel(line: string, levelFilter: string): boolean {
+	try {
+		const entry = JSON.parse(line);
+		return entry.level === levelFilter;
+	} catch {
+		return true;
+	}
+}
+
+function matchesSince(line: string, sinceMs: number): boolean {
+	try {
+		const entry = JSON.parse(line);
+		if (!entry.timestamp) return true;
+		const entryTime = new Date(entry.timestamp).getTime();
+		return entryTime >= sinceMs;
+	} catch {
+		return true;
+	}
+}
+
+function parseSince(since: string): number {
+	// Handle relative time (1h, 30m, 2d)
+	const match = since.match(/^(\d+)([smhd])$/);
+	if (match) {
+		const value = parseInt(match[1], 10);
+		const unit = match[2];
+		const multipliers: Record<string, number> = {
+			s: 1000,
+			m: 60 * 1000,
+			h: 60 * 60 * 1000,
+			d: 24 * 60 * 60 * 1000
+		};
+		return Date.now() - value * multipliers[unit];
+	}
+
+	// Try to parse as date
+	const date = new Date(since);
+	if (!isNaN(date.getTime())) {
+		return date.getTime();
+	}
+
+	return 0;
+}
+
+export default {
+	async execute(args: SearchArgs, opts: SearchOptions): Promise<void> {
+		const runtime = getVibesRuntime();
+		const maxResults = opts.max ? parseInt(opts.max, 10) : 100;
+		const sinceMs = opts.since ? parseSince(opts.since) : 0;
+
+		const flags = opts.ignoreCase ? 'gi' : 'g';
+		const pattern = new RegExp(args.pattern, flags);
+
+		// Get outputs to search
+		let outputIds: string[];
+		if (opts.output) {
+			outputIds = [opts.output];
+		} else {
+			const descriptors = runtime
+				.query<OutputDescriptor, OutputImplementation>('logging/output')
+				.enabled()
+				.descriptors();
+			outputIds = descriptors.map((d) => d.id);
+		}
+
+		const results: Array<{ output: string; line: string }> = [];
+
+		for (const outputId of outputIds) {
+			try {
+				const output = await runtime
+					.query<OutputDescriptor, OutputImplementation>('logging/output')
+					.withId(outputId)
+					.resolve();
+
+				// Read all available lines (up to a reasonable limit)
+				const lines = await output.read({ lines: 10000 });
+
+				for (const line of lines) {
+					// Apply filters
+					if (opts.level && !matchesLevel(line, opts.level)) continue;
+					if (sinceMs && !matchesSince(line, sinceMs)) continue;
+					if (!pattern.test(line)) continue;
+
+					results.push({ output: outputId, line });
+					if (results.length >= maxResults) break;
+				}
+			} catch {
+				// Skip outputs that can't be read
+			}
+
+			if (results.length >= maxResults) break;
+		}
+
+		if (results.length === 0) {
+			console.log('No matching entries found.');
+			return;
+		}
+
+		if (opts.json) {
+			const parsed = results.map(({ output, line }) => {
+				try {
+					return { output, ...JSON.parse(line) };
+				} catch {
+					return { output, raw: line };
+				}
+			});
+			console.log(JSON.stringify(parsed, null, 2));
+			return;
+		}
+
+		console.log(`\n🔍 Found ${results.length} matches\n`);
+		for (const { output, line } of results) {
+			const formatted = formatLine(line, pattern);
+			console.log(`[${output}] ${formatted}`);
+		}
+		console.log('');
+	}
+};

package/src/cli/logs.tail.descriptor.ts

@@ -0,0 +1,49 @@
+/**
+ * Logs Tail CLI Command Descriptor
+ *
+ * Follows a log output in real-time.
+ */
+
+import type { CLICommandAssetDescriptor } from './types.ts';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'logs.tail',
+	name: 'tail',
+	description: 'Follow a log output in real-time',
+	group: 'logs',
+
+	arguments: [
+		{
+			name: 'output',
+			description: 'Output ID to tail (e.g., mcp-server, file)',
+			required: false
+		}
+	],
+
+	options: [
+		{
+			flags: '-n, --lines <count>',
+			description: 'Number of initial lines to show',
+			default: '10'
+		},
+		{
+			flags: '-f, --filter <pattern>',
+			description: 'Filter lines by pattern'
+		},
+		{
+			flags: '-i, --ignore-case',
+			description: 'Case-insensitive filtering'
+		},
+		{
+			flags: '--level <level>',
+			description: 'Filter by log level (debug, info, warn, error)'
+		}
+	],
+
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

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

@@ -0,0 +1,105 @@
+/**
+ * Logs Tail CLI Command Implementation
+ *
+ * Follows a log output in real-time.
+ */
+
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import type { OutputDescriptor } from '../schemas/output.ts';
+import type { OutputImplementation, TailHandle } from '../kinds/output.ts';
+
+interface TailArgs {
+	output?: string;
+}
+
+interface TailOptions {
+	lines?: string;
+	filter?: string;
+	ignoreCase?: boolean;
+	level?: string;
+}
+
+// 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, levelFilter?: string): string | null {
+	try {
+		const entry = JSON.parse(line);
+		const level = entry.level ?? 'info';
+
+		// Filter by level if specified
+		if (levelFilter && level !== levelFilter) {
+			return null;
+		}
+
+		const color = LEVEL_COLORS[level] ?? '';
+		const timestamp = entry.timestamp?.slice(11, 19) ?? '';
+		const namespace = entry.namespace ?? '';
+		const message = entry.message ?? '';
+
+		return `${color}[${timestamp}] [${level.toUpperCase().padEnd(5)}] [${namespace}]${RESET} ${message}`;
+	} catch {
+		// Not JSON, return as-is
+		return line;
+	}
+}
+
+export default {
+	async execute(args: TailArgs, opts: TailOptions): 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) : 10;
+
+		console.log(`\n📜 Tailing ${outputId} (Ctrl+C to stop)\n`);
+
+		let handle: TailHandle;
+		try {
+			handle = output.tail(
+				(line) => {
+					const formatted = formatLine(line, opts.level);
+					if (formatted !== null) {
+						console.log(formatted);
+					}
+				},
+				{
+					lines,
+					filter: opts.filter,
+					ignoreCase: opts.ignoreCase
+				}
+			);
+		} catch (err) {
+			console.error(`Failed to tail: ${err instanceof Error ? err.message : String(err)}`);
+			process.exit(1);
+		}
+
+		// Handle Ctrl+C gracefully
+		process.on('SIGINT', () => {
+			console.log('\n\nStopping...');
+			handle.close();
+			process.exit(0);
+		});
+
+		// Keep process alive
+		await new Promise(() => {});
+	}
+};

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

@@ -0,0 +1,57 @@
+/**
+ * Logs View CLI Command Descriptor
+ *
+ * View log entries from an output.
+ */
+
+import type { CLICommandAssetDescriptor } from './types.ts';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'logs.view',
+	name: 'view',
+	description: 'View log entries from an output',
+	group: 'logs',
+
+	arguments: [
+		{
+			name: 'output',
+			description: 'Output ID to view (e.g., mcp-server, file)',
+			required: false
+		}
+	],
+
+	options: [
+		{
+			flags: '-n, --lines <count>',
+			description: 'Number of lines to show',
+			default: '50'
+		},
+		{
+			flags: '--offset <count>',
+			description: 'Skip this many lines from the end'
+		},
+		{
+			flags: '-f, --filter <pattern>',
+			description: 'Filter lines by pattern'
+		},
+		{
+			flags: '-i, --ignore-case',
+			description: 'Case-insensitive filtering'
+		},
+		{
+			flags: '--json',
+			description: 'Output as JSON'
+		},
+		{
+			flags: '--raw',
+			description: 'Output raw log lines without formatting'
+		}
+	],
+
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

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

@@ -0,0 +1,108 @@
+/**
+ * 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

@@ -0,0 +1,59 @@
+/**
+ * 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

@@ -0,0 +1,36 @@
+/**
+ * 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>;
+}