@vibesdotdev/cli 0.0.1

package/src/patterns/config-namespace.ts

@@ -0,0 +1,251 @@
+/**
+ * Config Namespace Pattern Implementation
+ *
+ * Generates get/set/reset/list commands for a config namespace.
+ */
+
+import type { Command } from 'commander';
+import type { VibesRuntime } from '@vibesdotdev/runtime/api/runtime';
+import type { CLIConfigNamespaceGroupDescriptor } from './schemas';
+import type { PatternImplementation } from './pattern-types';
+import type { CommandContext } from '../schemas/surface';
+import type { ConfigContext } from '../providers';
+
+function isConfigContext(value: unknown): value is ConfigContext {
+	return (
+		!!value &&
+		typeof value === 'object' &&
+		'get' in value &&
+		typeof value.get === 'function' &&
+		'set' in value &&
+		typeof value.set === 'function' &&
+		'getNamespace' in value &&
+		typeof value.getNamespace === 'function' &&
+		'delete' in value &&
+		typeof value.delete === 'function'
+	);
+}
+
+export class ConfigNamespacePatternImpl implements PatternImplementation<CLIConfigNamespaceGroupDescriptor> {
+	constructor(private runtime: VibesRuntime) {}
+
+	async register(
+		descriptor: CLIConfigNamespaceGroupDescriptor,
+		parent: Command,
+		context: CommandContext
+	): Promise<void> {
+		const { name, description, configNamespace } = descriptor;
+		const cmds = configNamespace.commands ?? {};
+
+		const groupCmd = parent.command(name).description(description);
+
+		if (cmds.get !== false) this.registerGet(groupCmd, descriptor, context);
+		if (cmds.set !== false) this.registerSet(groupCmd, descriptor, context);
+		if (cmds.reset !== false) this.registerReset(groupCmd, descriptor, context);
+		this.registerList(groupCmd, descriptor, context);
+	}
+
+	private async getConfigService(ctx: CommandContext): Promise<ConfigContext | null> {
+		if (isConfigContext(ctx.config)) return ctx.config;
+
+		try {
+			const config = await this.runtime.context<ConfigContext>('config/context');
+			return isConfigContext(config) ? config : null;
+		} catch {
+			return null;
+		}
+	}
+
+	private registerGet(
+		parent: Command,
+		d: CLIConfigNamespaceGroupDescriptor,
+		ctx: CommandContext
+	): void {
+		const ns = d.configNamespace.namespace;
+
+		parent
+			.command('get [key]')
+			.description(`Get config value(s) for ${ns}`)
+			.option('-f, --format <format>', 'Output format', 'yaml')
+			.action(async (key: string | undefined, opts) => {
+				const svc = await this.getConfigService(ctx);
+				if (!svc) {
+					ctx.ui?.error('Config service not available');
+					return;
+				}
+
+				if (key) {
+					const val = await svc.get(`${ns}.${key}`);
+					if (val === undefined) {
+						ctx.ui?.warn(`Not found: ${ns}.${key}`);
+						return;
+					}
+					this.output(val, opts.format, ctx);
+				} else {
+					const vals = await svc.getNamespace(ns);
+					this.output(vals, opts.format, ctx);
+				}
+			});
+	}
+
+	private registerSet(
+		parent: Command,
+		d: CLIConfigNamespaceGroupDescriptor,
+		ctx: CommandContext
+	): void {
+		const ns = d.configNamespace.namespace;
+
+		parent
+			.command('set <key> <value>')
+			.description(`Set config value for ${ns}`)
+			.option('--json', 'Parse value as JSON')
+			.action(async (key: string, value: string, opts) => {
+				const svc = await this.getConfigService(ctx);
+				if (!svc) {
+					ctx.ui?.error('Config service not available');
+					return;
+				}
+
+				let parsed: unknown = value;
+				if (opts.json) {
+					try {
+						parsed = JSON.parse(value);
+					} catch (e) {
+						ctx.ui?.error(`Invalid JSON: ${e}`);
+						return;
+					}
+				} else {
+					parsed = this.parseValue(value);
+				}
+
+				await svc.set(`${ns}.${key}`, parsed);
+				ctx.ui?.success(`Set ${ns}.${key} = ${JSON.stringify(parsed)}`);
+			});
+	}
+
+	private registerReset(
+		parent: Command,
+		d: CLIConfigNamespaceGroupDescriptor,
+		ctx: CommandContext
+	): void {
+		const ns = d.configNamespace.namespace;
+		const defaults = d.configNamespace.defaults ?? {};
+
+		parent
+			.command('reset [key]')
+			.description(`Reset config to defaults for ${ns}`)
+			.option('--all', 'Reset all keys')
+			.option('-y, --yes', 'Skip confirmation')
+			.action(async (key: string | undefined, opts) => {
+				const svc = await this.getConfigService(ctx);
+				if (!svc) {
+					ctx.ui?.error('Config service not available');
+					return;
+				}
+
+				if (opts.all) {
+					if (!opts.yes) {
+						ctx.ui?.warn(`Use --yes to confirm reset of all ${ns} config`);
+						return;
+					}
+					for (const [k, v] of Object.entries(defaults)) {
+						await svc.set(`${ns}.${k}`, v);
+					}
+					ctx.ui?.success(`Reset all ${ns} config to defaults`);
+				} else if (key) {
+					const def = defaults[key];
+					if (def === undefined) {
+						await svc.delete(`${ns}.${key}`);
+						ctx.ui?.success(`Deleted ${ns}.${key}`);
+					} else {
+						await svc.set(`${ns}.${key}`, def);
+						ctx.ui?.success(`Reset ${ns}.${key} to ${JSON.stringify(def)}`);
+					}
+				} else {
+					ctx.ui?.error('Specify a key or use --all');
+				}
+			});
+	}
+
+	private registerList(
+		parent: Command,
+		d: CLIConfigNamespaceGroupDescriptor,
+		ctx: CommandContext
+	): void {
+		const ns = d.configNamespace.namespace;
+		const defaults = d.configNamespace.defaults ?? {};
+
+		parent
+			.command('list')
+			.alias('ls')
+			.description(`List config keys for ${ns}`)
+			.option('--with-values', 'Include values')
+			.option('--with-defaults', 'Include defaults')
+			.action(async (opts) => {
+				const svc = await this.getConfigService(ctx);
+				if (!svc) {
+					ctx.ui?.error('Config service not available');
+					return;
+				}
+
+				const current = await svc.getNamespace(ns);
+				const allKeys = new Set([...Object.keys(defaults), ...Object.keys(current)]);
+
+				const rows: Array<{ key: string; value?: unknown; default?: unknown }> = [];
+				for (const key of allKeys) {
+					const row: { key: string; value?: unknown; default?: unknown } = { key };
+					if (opts.withValues) row.value = current[key];
+					if (opts.withDefaults) row.default = defaults[key];
+					rows.push(row);
+				}
+
+				if (rows.length === 0) {
+					ctx.ui?.info(`No keys in ${ns}`);
+					return;
+				}
+
+				ctx.ui?.table(rows);
+			});
+	}
+
+	private output(data: unknown, format: string, ctx: CommandContext): void {
+		if (!ctx.ui) {
+			process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+			return;
+		}
+
+		switch (format) {
+			case 'json':
+				ctx.ui.json(data);
+				break;
+			case 'yaml':
+				ctx.ui.yaml(data);
+				break;
+			case 'table':
+				if (typeof data === 'object' && data && !Array.isArray(data)) {
+					const rows = Object.entries(data).map(([k, v]) => ({
+						key: k,
+						value: typeof v === 'object' ? JSON.stringify(v) : v
+					}));
+					ctx.ui.table(rows);
+				} else {
+					ctx.ui.yaml(data);
+				}
+				break;
+			default:
+				ctx.ui.yaml(data);
+		}
+	}
+
+	private parseValue(value: string): unknown {
+		if (value === 'true') return true;
+		if (value === 'false') return false;
+		const num = Number(value);
+		if (!isNaN(num) && value.trim() !== '') return num;
+		try {
+			return JSON.parse(value);
+		} catch {
+			return value;
+		}
+	}
+}

package/src/patterns/crud.ts

@@ -0,0 +1,217 @@
+/**
+ * CRUD Pattern Implementation
+ *
+ * Generates list/get/create/update/delete commands for a storage kind.
+ */
+
+import type { Command } from 'commander';
+import type { VibesRuntime } from '@vibesdotdev/runtime/api/runtime';
+import type { CLICRUDGroupDescriptor } from './schemas';
+import type { PatternImplementation } from './pattern-types';
+import type { CommandContext } from '../schemas/surface';
+import { requestCLIExit } from '../providers';
+
+interface StorageAdapter<T = unknown> {
+	list(options?: { limit?: number; offset?: number; sortBy?: string }): Promise<T[]>;
+	get(id: string): Promise<T | null>;
+	create(data: Partial<T>): Promise<T>;
+	update(id: string, data: Partial<T>): Promise<T>;
+	delete(id: string): Promise<void>;
+}
+
+export class CRUDPatternImpl implements PatternImplementation<CLICRUDGroupDescriptor> {
+	constructor(private runtime: VibesRuntime) {}
+
+	async register(
+		descriptor: CLICRUDGroupDescriptor,
+		parent: Command,
+		context: CommandContext
+	): Promise<void> {
+		const { target, crud, name, description } = descriptor;
+
+		const groupCmd = parent.command(name).description(description);
+
+		const getAdapter = async (): Promise<StorageAdapter> => {
+			return this.runtime.query(target.kind).withId(target.id).resolve() as Promise<StorageAdapter>;
+		};
+
+		if (crud?.list?.enabled !== false) {
+			this.registerList(groupCmd, descriptor, getAdapter, context);
+		}
+		if (crud?.get?.enabled !== false) {
+			this.registerGet(groupCmd, descriptor, getAdapter, context);
+		}
+		if (crud?.create?.enabled !== false) {
+			this.registerCreate(groupCmd, descriptor, getAdapter, context);
+		}
+		if (crud?.update?.enabled !== false) {
+			this.registerUpdate(groupCmd, descriptor, getAdapter, context);
+		}
+		if (crud?.delete?.enabled !== false) {
+			this.registerDelete(groupCmd, descriptor, getAdapter, context);
+		}
+	}
+
+	private registerList(
+		parent: Command,
+		descriptor: CLICRUDGroupDescriptor,
+		getAdapter: () => Promise<StorageAdapter>,
+		ctx: CommandContext
+	): void {
+		const cfg = descriptor.crud?.list ?? {};
+
+		parent
+			.command('list')
+			.alias('ls')
+			.description(`List all ${descriptor.name}`)
+			.option('-f, --format <format>', 'Output format', cfg.defaultFormat ?? 'table')
+			.option('-l, --limit <n>', 'Limit results', '50')
+			.option('--offset <n>', 'Offset', '0')
+			.option('--sort <field>', 'Sort by', cfg.sortBy)
+			.action(async (opts) => {
+				const adapter = await getAdapter();
+				const items = await adapter.list({
+					limit: parseInt(opts.limit, 10),
+					offset: parseInt(opts.offset, 10),
+					sortBy: opts.sort
+				});
+				this.output(items, opts.format, ctx, cfg.columns);
+			});
+	}
+
+	private registerGet(
+		parent: Command,
+		descriptor: CLICRUDGroupDescriptor,
+		getAdapter: () => Promise<StorageAdapter>,
+		ctx: CommandContext
+	): void {
+		const cfg = descriptor.crud?.get ?? {};
+
+		parent
+			.command(`get <${cfg.idParam ?? 'id'}>`)
+			.description(`Get a ${descriptor.name} by ID`)
+			.option('-f, --format <format>', 'Output format', 'yaml')
+			.action(async (id: string, opts) => {
+				const adapter = await getAdapter();
+				const item = await adapter.get(id);
+				if (!item) {
+					ctx.ui?.error(`Not found: ${id}`);
+					requestCLIExit(1);
+				}
+				this.output(item, opts.format, ctx);
+			});
+	}
+
+	private registerCreate(
+		parent: Command,
+		descriptor: CLICRUDGroupDescriptor,
+		getAdapter: () => Promise<StorageAdapter>,
+		ctx: CommandContext
+	): void {
+		parent
+			.command('create')
+			.description(`Create a new ${descriptor.name}`)
+			.option('-f, --format <format>', 'Output format', 'yaml')
+			.option('--json <data>', 'JSON data')
+			.action(async (opts) => {
+				if (!opts.json) {
+					ctx.ui?.error('--json required');
+					requestCLIExit(2);
+				}
+				const adapter = await getAdapter();
+				const created = await adapter.create(JSON.parse(opts.json));
+				ctx.ui?.success(`Created ${descriptor.name}`);
+				this.output(created, opts.format, ctx);
+			});
+	}
+
+	private registerUpdate(
+		parent: Command,
+		descriptor: CLICRUDGroupDescriptor,
+		getAdapter: () => Promise<StorageAdapter>,
+		ctx: CommandContext
+	): void {
+		parent
+			.command('update <id>')
+			.description(`Update a ${descriptor.name}`)
+			.option('-f, --format <format>', 'Output format', 'yaml')
+			.option('--json <data>', 'JSON data')
+			.option('--set <key=value...>', 'Set fields')
+			.action(async (id: string, opts) => {
+				let data: Record<string, unknown> = {};
+				if (opts.json) {
+					data = JSON.parse(opts.json);
+				} else if (opts.set) {
+					for (const pair of opts.set) {
+						const [key, ...rest] = pair.split('=');
+						data[key] = this.parseValue(rest.join('='));
+					}
+				} else {
+					ctx.ui?.error('--json or --set required');
+					requestCLIExit(2);
+				}
+				const adapter = await getAdapter();
+				const updated = await adapter.update(id, data);
+				ctx.ui?.success(`Updated: ${id}`);
+				this.output(updated, opts.format, ctx);
+			});
+	}
+
+	private registerDelete(
+		parent: Command,
+		descriptor: CLICRUDGroupDescriptor,
+		getAdapter: () => Promise<StorageAdapter>,
+		ctx: CommandContext
+	): void {
+		const cfg = descriptor.crud?.delete ?? {};
+
+		const cmd = parent.command('delete <id>').description(`Delete a ${descriptor.name}`);
+
+		if (cfg.confirm !== false) {
+			cmd.option('-y, --yes', 'Skip confirmation');
+		}
+
+		cmd.action(async (id: string, opts) => {
+			if (cfg.confirm !== false && !opts.yes) {
+				ctx.ui?.warn(`Use --yes to confirm deletion of: ${id}`);
+				requestCLIExit(2);
+			}
+			const adapter = await getAdapter();
+			await adapter.delete(id);
+			ctx.ui?.success(`Deleted: ${id}`);
+		});
+	}
+
+	private output(data: unknown, format: string, ctx: CommandContext, columns?: string[]): void {
+		if (!ctx.ui) {
+			process.stdout.write(`${JSON.stringify(data, null, 2)}\n`);
+			return;
+		}
+
+		switch (format) {
+			case 'json':
+				ctx.ui.json(data);
+				break;
+			case 'yaml':
+				ctx.ui.yaml(data);
+				break;
+			case 'table':
+				if (Array.isArray(data)) {
+					ctx.ui.table(data, { columns });
+				} else {
+					ctx.ui.yaml(data);
+				}
+				break;
+			default:
+				ctx.ui.json(data);
+		}
+	}
+
+	private parseValue(value: string): unknown {
+		try {
+			return JSON.parse(value);
+		} catch {
+			return value;
+		}
+	}
+}

package/src/patterns/index.ts

@@ -0,0 +1,24 @@
+/**
+ * CLI Patterns
+ *
+ * Pattern-based command generation for the CLI surface.
+ */
+
+export { PatternResolver, createPatternResolver, type PatternImplementation } from './resolver';
+
+export {
+	isPatternDescriptor,
+	getPatternType,
+	type CLIPatternDescriptor,
+	type CLICRUDGroupDescriptor,
+	type CLIToolWrapperCommandDescriptor,
+	type CLILogViewerGroupDescriptor,
+	type CLIProcessManagerGroupDescriptor,
+	type CLIConfigNamespaceGroupDescriptor
+} from './schemas';
+
+export { CRUDPatternImpl } from './crud';
+export { ToolWrapperPatternImpl } from './tool-wrapper';
+export { LogViewerPatternImpl } from './log-viewer';
+export { ProcessManagerPatternImpl } from './process-manager';
+export { ConfigNamespacePatternImpl } from './config-namespace';

package/src/patterns/log-viewer.ts

@@ -0,0 +1,118 @@
+/**
+ * Log Viewer Pattern Implementation
+ *
+ * Generates commands for viewing logs.
+ */
+
+import type { Command } from 'commander';
+import type { VibesRuntime } from '@vibesdotdev/runtime/api/runtime';
+import type { CLILogViewerGroupDescriptor } from './schemas';
+import type { PatternImplementation } from './pattern-types';
+import type { CommandContext } from '../schemas/surface';
+
+interface PMLogContext extends CommandContext {
+	pm?: {
+		tailLogs(
+			targetId: string,
+			options: {
+				lines: number;
+				levels?: string[];
+				follow?: boolean;
+			}
+		): Promise<void>;
+	};
+}
+
+export class LogViewerPatternImpl implements PatternImplementation<CLILogViewerGroupDescriptor> {
+	constructor(private runtime: VibesRuntime) {}
+
+	async register(
+		descriptor: CLILogViewerGroupDescriptor,
+		parent: Command,
+		context: CommandContext
+	): Promise<void> {
+		const { name, description, logViewer } = descriptor;
+
+		const groupCmd = parent.command(name).description(description);
+
+		this.registerTail(groupCmd, descriptor, context);
+		this.registerSearch(groupCmd, descriptor, context);
+		this.registerLevels(groupCmd, descriptor, context);
+	}
+
+	private registerTail(
+		parent: Command,
+		descriptor: CLILogViewerGroupDescriptor,
+		ctx: CommandContext
+	): void {
+		const cfg = descriptor.logViewer;
+
+		const cmd = parent
+			.command('tail')
+			.alias('logs')
+			.description(`View recent logs for ${descriptor.name}`)
+			.option('-n, --lines <n>', 'Number of lines', String(cfg.defaultLines))
+			.option('-l, --level <levels...>', 'Filter by level', cfg.defaultLevels);
+
+		if (cfg.follow) {
+			cmd.option('-f, --follow', 'Follow output');
+		}
+
+		if (cfg.filters) {
+			for (const f of cfg.filters) {
+				cmd.option(f.flag, f.description);
+			}
+		}
+
+		cmd.action(async (opts) => {
+			const pm = (ctx as PMLogContext).pm;
+			if (!pm?.tailLogs) {
+				ctx.ui?.warn('Log streaming not available');
+				return;
+			}
+
+			await pm.tailLogs(descriptor.target.id, {
+				lines: parseInt(opts.lines, 10),
+				levels: opts.level,
+				follow: opts.follow
+			});
+		});
+	}
+
+	private registerSearch(
+		parent: Command,
+		descriptor: CLILogViewerGroupDescriptor,
+		ctx: CommandContext
+	): void {
+		parent
+			.command('search <pattern>')
+			.description(`Search logs for ${descriptor.name}`)
+			.option('-n, --lines <n>', 'Context lines', '3')
+			.option('-l, --level <levels...>', 'Filter by level')
+			.option('--since <time>', 'Since time')
+			.option('--until <time>', 'Until time')
+			.action(async (pattern: string, opts) => {
+				ctx.ui?.warn('Log search not yet implemented');
+			});
+	}
+
+	private registerLevels(
+		parent: Command,
+		descriptor: CLILogViewerGroupDescriptor,
+		ctx: CommandContext
+	): void {
+		parent
+			.command('levels')
+			.description('Show available log levels')
+			.action(() => {
+				const levels = ['trace', 'debug', 'info', 'warn', 'error', 'fatal'];
+				const defaults = descriptor.logViewer.defaultLevels ?? [];
+
+				ctx.ui?.info('Available log levels:');
+				for (const level of levels) {
+					const marker = defaults.includes(level) ? ' (default)' : '';
+					ctx.ui?.info(`  - ${level}${marker}`);
+				}
+			});
+	}
+}

package/src/patterns/pattern-types.ts

@@ -0,0 +1,22 @@
+/**
+ * CLI Pattern Type Definitions
+ *
+ * Shared types to avoid circular dependencies between resolver and pattern implementations.
+ */
+
+import type { Command } from 'commander';
+import type { CLIPatternDescriptor } from './schemas';
+import type { CommandContext } from '../schemas/surface';
+
+/**
+ * Pattern implementation interface
+ *
+ * All pattern implementations must implement this interface to register
+ * their commands with the CLI.
+ */
+export interface PatternImplementation<TDescriptor extends CLIPatternDescriptor> {
+	/**
+	 * Register a pattern descriptor as commands on the parent command
+	 */
+	register(descriptor: TDescriptor, parent: Command, context: CommandContext): Promise<void>;
+}