@vibesdotdev/cli 0.0.1

package/src/patterns/process-manager.ts

@@ -0,0 +1,180 @@
+/**
+ * Process Manager Pattern Implementation
+ *
+ * Generates start/stop/restart/status commands for a daemon.
+ */
+
+import type { Command } from 'commander';
+import type { VibesRuntime } from '@vibesdotdev/runtime/api/runtime';
+import type { CLIProcessManagerGroupDescriptor } from './schemas';
+import type { PatternImplementation } from './pattern-types';
+import type { CommandContext } from '../schemas/surface';
+
+/** Extended context with PM client available */
+interface PMCommandContext extends CommandContext {
+	pm?: {
+		start(processId: string, opts: Record<string, unknown>): Promise<void>;
+		stop(processId: string, opts: Record<string, unknown>): Promise<void>;
+		restart(processId: string, opts: Record<string, unknown>): Promise<void>;
+		status(processId: string): Promise<Record<string, unknown>>;
+		logs(processId: string, opts: Record<string, unknown>): Promise<void>;
+	};
+}
+
+export class ProcessManagerPatternImpl implements PatternImplementation<CLIProcessManagerGroupDescriptor> {
+	constructor(private runtime: VibesRuntime) {}
+
+	async register(
+		descriptor: CLIProcessManagerGroupDescriptor,
+		parent: Command,
+		context: CommandContext
+	): Promise<void> {
+		const { name, description, processManager } = descriptor;
+		const cmds = processManager.commands ?? {};
+
+		const groupCmd = parent.command(name).description(description);
+
+		if (cmds.start !== false) this.registerStart(groupCmd, descriptor, context);
+		if (cmds.stop !== false) this.registerStop(groupCmd, descriptor, context);
+		if (cmds.restart !== false) this.registerRestart(groupCmd, descriptor, context);
+		if (cmds.status !== false) this.registerStatus(groupCmd, descriptor, context);
+		if (cmds.logs !== false) this.registerLogs(groupCmd, descriptor, context);
+	}
+
+	private registerStart(
+		parent: Command,
+		d: CLIProcessManagerGroupDescriptor,
+		ctx: CommandContext
+	): void {
+		parent
+			.command('start')
+			.description(`Start ${d.name}`)
+			.option('--detach', 'Run in background', true)
+			.option('--env <vars...>', 'Environment variables')
+			.action(async (opts) => {
+				const pm = (ctx as PMCommandContext).pm;
+				if (!pm?.start) {
+					ctx.ui?.error('Process manager not available');
+					return;
+				}
+
+				const env: Record<string, string> = {};
+				if (opts.env) {
+					for (const pair of opts.env) {
+						const [k, ...v] = pair.split('=');
+						env[k] = v.join('=');
+					}
+				}
+
+				await pm.start(d.processManager.processId, { detach: opts.detach, env });
+				ctx.ui?.success(`Started ${d.name}`);
+			});
+	}
+
+	private registerStop(
+		parent: Command,
+		d: CLIProcessManagerGroupDescriptor,
+		ctx: CommandContext
+	): void {
+		parent
+			.command('stop')
+			.description(`Stop ${d.name}`)
+			.option('--force', 'Force stop')
+			.option('--timeout <s>', 'Timeout', '10')
+			.action(async (opts) => {
+				const pm = (ctx as PMCommandContext).pm;
+				if (!pm?.stop) {
+					ctx.ui?.error('Process manager not available');
+					return;
+				}
+
+				await pm.stop(d.processManager.processId, {
+					force: opts.force,
+					timeout: parseInt(opts.timeout, 10) * 1000
+				});
+				ctx.ui?.success(`Stopped ${d.name}`);
+			});
+	}
+
+	private registerRestart(
+		parent: Command,
+		d: CLIProcessManagerGroupDescriptor,
+		ctx: CommandContext
+	): void {
+		parent
+			.command('restart')
+			.description(`Restart ${d.name}`)
+			.option('--force', 'Force restart')
+			.action(async (opts) => {
+				const pm = (ctx as PMCommandContext).pm;
+				if (!pm?.restart) {
+					ctx.ui?.error('Process manager not available');
+					return;
+				}
+
+				await pm.restart(d.processManager.processId, { force: opts.force });
+				ctx.ui?.success(`Restarted ${d.name}`);
+			});
+	}
+
+	private registerStatus(
+		parent: Command,
+		d: CLIProcessManagerGroupDescriptor,
+		ctx: CommandContext
+	): void {
+		parent
+			.command('status')
+			.description(`Show status of ${d.name}`)
+			.option('-f, --format <format>', 'Output format', 'table')
+			.option('--health', 'Include health check')
+			.action(async (opts) => {
+				const pm = (ctx as PMCommandContext).pm;
+				if (!pm?.status) {
+					ctx.ui?.error('Process manager not available');
+					return;
+				}
+
+				const status = await pm.status(d.processManager.processId);
+
+				if (opts.health && d.processManager.healthCheck?.url) {
+					try {
+						const res = await fetch(d.processManager.healthCheck.url);
+						status.health = { ok: res.ok, code: res.status };
+					} catch (e) {
+						status.health = { ok: false, error: String(e) };
+					}
+				}
+
+				if (opts.format === 'json') {
+					ctx.ui?.json(status);
+				} else {
+					ctx.ui?.info(`${d.name}: ${status.state ?? 'unknown'}`);
+					if (status.pid) ctx.ui?.info(`  PID: ${status.pid}`);
+				}
+			});
+	}
+
+	private registerLogs(
+		parent: Command,
+		d: CLIProcessManagerGroupDescriptor,
+		ctx: CommandContext
+	): void {
+		parent
+			.command('logs')
+			.description(`View logs for ${d.name}`)
+			.option('-n, --lines <n>', 'Lines', '50')
+			.option('-f, --follow', 'Follow')
+			.action(async (opts) => {
+				const pm = (ctx as PMCommandContext).pm;
+				if (!pm?.logs) {
+					ctx.ui?.error('Process manager not available');
+					return;
+				}
+
+				await pm.logs(d.processManager.processId, {
+					lines: parseInt(opts.lines, 10),
+					follow: opts.follow
+				});
+			});
+	}
+}

package/src/patterns/resolver.contracts.ts

@@ -0,0 +1,15 @@
+/**
+ * Pattern resolver contracts.
+ *
+ * Extracted from `./resolver.ts` so each pattern implementation can
+ * implement `PatternImplementation` without forming a cycle back through
+ * the resolver (which itself dynamically imports the pattern modules).
+ */
+
+import type { Command } from 'commander';
+import type { CommandContext } from '../schemas/surface';
+import type { CLIPatternDescriptor } from './schemas';
+
+export interface PatternImplementation<TDescriptor extends CLIPatternDescriptor> {
+	register(descriptor: TDescriptor, parent: Command, context: CommandContext): Promise<void>;
+}

package/src/patterns/resolver.ts

@@ -0,0 +1,86 @@
+/**
+ * CLI Pattern Resolver
+ *
+ * Resolves pattern descriptors to Commander.js commands.
+ */
+
+import type { Command } from 'commander';
+import type { VibesRuntime } from '@vibesdotdev/runtime/api/runtime';
+import type { CLIPatternDescriptor } from './schemas';
+import { isPatternDescriptor, getPatternType } from './schemas';
+import { CRUDPatternImpl } from './crud';
+import { ToolWrapperPatternImpl } from './tool-wrapper';
+import { LogViewerPatternImpl } from './log-viewer';
+import { ProcessManagerPatternImpl } from './process-manager';
+import { ConfigNamespacePatternImpl } from './config-namespace';
+import type { CommandContext } from '../schemas/surface';
+import type { PatternImplementation } from './pattern-types';
+export type { PatternImplementation } from './pattern-types';
+
+/**
+ * Pattern resolver
+ */
+export class PatternResolver {
+	private patterns = new Map<string, PatternImplementation<any>>();
+
+	constructor(private runtime: VibesRuntime) {}
+
+	/**
+	 * Register a pattern implementation
+	 */
+	registerPattern<T extends CLIPatternDescriptor>(
+		patternType: string,
+		implementation: PatternImplementation<T>
+	): void {
+		this.patterns.set(patternType, implementation);
+	}
+
+	/**
+	 * Check if descriptor is a pattern
+	 */
+	isPattern(descriptor: unknown): descriptor is CLIPatternDescriptor {
+		return isPatternDescriptor(descriptor);
+	}
+
+	/**
+	 * Resolve and register a pattern descriptor
+	 */
+	async resolve(
+		descriptor: CLIPatternDescriptor,
+		parent: Command,
+		context: CommandContext
+	): Promise<void> {
+		const patternType = getPatternType(descriptor);
+		const impl = this.patterns.get(patternType);
+
+		if (!impl) {
+			throw new Error(
+				`No pattern implementation for '${patternType}'. Available: ${[...this.patterns.keys()].join(', ')}`
+			);
+		}
+
+		await impl.register(descriptor, parent, context);
+	}
+
+	/**
+	 * Get available pattern types
+	 */
+	getPatternTypes(): string[] {
+		return [...this.patterns.keys()];
+	}
+}
+
+/**
+ * Create pattern resolver with built-in patterns
+ */
+export async function createPatternResolver(runtime: VibesRuntime): Promise<PatternResolver> {
+	const resolver = new PatternResolver(runtime);
+
+	resolver.registerPattern('crud', new CRUDPatternImpl(runtime));
+	resolver.registerPattern('tool-wrapper', new ToolWrapperPatternImpl(runtime));
+	resolver.registerPattern('log-viewer', new LogViewerPatternImpl(runtime));
+	resolver.registerPattern('process-manager', new ProcessManagerPatternImpl(runtime));
+	resolver.registerPattern('config-namespace', new ConfigNamespacePatternImpl(runtime));
+
+	return resolver;
+}

package/src/patterns/schemas.ts

@@ -0,0 +1,146 @@
+/**
+ * CLI Pattern Schemas
+ *
+ * Extended CLI descriptor schemas that support pattern-based command generation.
+ * Uses pattern schemas from the universal runtime.
+ */
+
+import * as z from 'zod/v4';
+import { RuntimeDescriptorSchema } from '@vibesdotdev/runtime/schemas/descriptor';
+import {
+	type ConfigNamespacePatternConfig,
+	type CRUDPatternConfig,
+	type LogViewerPatternConfig,
+	PatternTargetSchema,
+	CRUDPatternConfigSchema,
+	ToolWrapperPatternConfigSchema,
+	LogViewerPatternConfigSchema,
+	ProcessManagerPatternConfigSchema,
+	ConfigNamespacePatternConfigSchema,
+	type PatternTarget,
+	type ProcessManagerPatternConfig,
+	type ToolWrapperPatternConfig
+} from '@vibesdotdev/runtime/schemas/pattern';
+import type {
+	CLIConfigNamespaceGroupDescriptor,
+	CLICRUDGroupDescriptor,
+	CLILogViewerGroupDescriptor,
+	CLIPatternDescriptor,
+	CLIProcessManagerGroupDescriptor,
+	CLIToolWrapperCommandDescriptor
+} from '../schemas/types';
+
+/**
+ * CLI Group with CRUD pattern
+ */
+export const CLICRUDGroupDescriptorSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('cli/group'),
+	name: z.string().min(1),
+	description: z.string().min(1),
+	parent: z.string().optional(),
+	pattern: z.literal('crud'),
+	target: PatternTargetSchema,
+	crud: CRUDPatternConfigSchema,
+	surfaces: z.array(z.enum(['cli', 'web', 'worker', 'bridge'])).default(['cli']),
+	internal: z.boolean().default(false)
+});
+
+/**
+ * CLI Command with tool-wrapper pattern
+ */
+export const CLIToolWrapperCommandDescriptorSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('cli/command'),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	group: z.string().min(1),
+	pattern: z.literal('tool-wrapper'),
+	target: PatternTargetSchema,
+	toolWrapper: ToolWrapperPatternConfigSchema,
+	surfaces: z.array(z.enum(['cli', 'web', 'worker', 'bridge'])).default(['cli']),
+	internal: z.boolean().default(false),
+	order: z.number().int().optional()
+});
+
+/**
+ * CLI Group with log-viewer pattern
+ */
+export const CLILogViewerGroupDescriptorSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('cli/group'),
+	name: z.string().min(1),
+	description: z.string().min(1),
+	parent: z.string().optional(),
+	pattern: z.literal('log-viewer'),
+	target: PatternTargetSchema,
+	logViewer: LogViewerPatternConfigSchema,
+	surfaces: z.array(z.enum(['cli', 'web', 'worker', 'bridge'])).default(['cli']),
+	internal: z.boolean().default(false)
+});
+
+/**
+ * CLI Group with process-manager pattern
+ */
+export const CLIProcessManagerGroupDescriptorSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('cli/group'),
+	name: z.string().min(1),
+	description: z.string().min(1),
+	parent: z.string().optional(),
+	pattern: z.literal('process-manager'),
+	target: PatternTargetSchema,
+	processManager: ProcessManagerPatternConfigSchema,
+	surfaces: z.array(z.enum(['cli', 'web', 'worker', 'bridge'])).default(['cli']),
+	internal: z.boolean().default(false)
+});
+
+/**
+ * CLI Group with config-namespace pattern
+ */
+export const CLIConfigNamespaceGroupDescriptorSchema = RuntimeDescriptorSchema.extend({
+	kind: z.literal('cli/group'),
+	name: z.string().min(1),
+	description: z.string().min(1),
+	parent: z.string().optional(),
+	pattern: z.literal('config-namespace'),
+	target: PatternTargetSchema.optional(),
+	configNamespace: ConfigNamespacePatternConfigSchema,
+	surfaces: z.array(z.enum(['cli', 'web', 'worker', 'bridge'])).default(['cli']),
+	internal: z.boolean().default(false)
+});
+
+/**
+ * Union of all pattern-based CLI descriptors
+ */
+export const CLIPatternDescriptorSchema = z.union([
+	CLICRUDGroupDescriptorSchema,
+	CLIToolWrapperCommandDescriptorSchema,
+	CLILogViewerGroupDescriptorSchema,
+	CLIProcessManagerGroupDescriptorSchema,
+	CLIConfigNamespaceGroupDescriptorSchema
+]);
+
+export type {
+	CLIConfigNamespaceGroupDescriptor,
+	CLICRUDGroupDescriptor,
+	CLILogViewerGroupDescriptor,
+	CLIPatternDescriptor,
+	CLIProcessManagerGroupDescriptor,
+	CLIToolWrapperCommandDescriptor
+} from '../schemas/types';
+
+/**
+ * Type guard for pattern descriptors
+ */
+export function isPatternDescriptor(descriptor: unknown): descriptor is CLIPatternDescriptor {
+	if (!descriptor || typeof descriptor !== 'object') return false;
+	return (
+		'pattern' in descriptor && typeof (descriptor as Record<string, unknown>).pattern === 'string'
+	);
+}
+
+/**
+ * Get pattern type from descriptor
+ */
+export function getPatternType(
+	descriptor: CLIPatternDescriptor
+): 'crud' | 'tool-wrapper' | 'log-viewer' | 'process-manager' | 'config-namespace' {
+	return descriptor.pattern;
+}

package/src/patterns/tool-wrapper.ts

@@ -0,0 +1,165 @@
+/**
+ * Tool Wrapper Pattern Implementation
+ *
+ * Wraps a tools/tool as a CLI command.
+ */
+
+import type { Command } from 'commander';
+import type { VibesRuntime } from '@vibesdotdev/runtime/api/runtime';
+import type { CLIToolWrapperCommandDescriptor } from './schemas';
+import type { PatternImplementation } from './pattern-types';
+import type { CommandContext } from '../schemas/surface';
+import type { ToolCallContext } from '@vibesdotdev/runtime/schemas/tool-call';
+import type { LoggerImplementation } from '@vibesdotdev/logging/kinds/logger';
+
+type ToolAssetDescriptor = {
+	id: string;
+	kind: string;
+	description?: string;
+};
+
+type ToolImplementation = {
+	execute(input: Record<string, unknown>, runtime: VibesRuntime, context: ToolCallContext): Promise<unknown>;
+};
+
+export class ToolWrapperPatternImpl implements PatternImplementation<CLIToolWrapperCommandDescriptor> {
+	constructor(private runtime: VibesRuntime) {}
+
+	async register(
+		descriptor: CLIToolWrapperCommandDescriptor,
+		parent: Command,
+		context: CommandContext
+	): Promise<void> {
+		const { target, toolWrapper, name, group } = descriptor;
+
+		// Get tool descriptor for metadata
+		const toolDesc = this.runtime
+			.query(target.kind)
+			.withId(target.id)
+			.firstDescriptor() as ToolAssetDescriptor | null;
+
+		const description = descriptor.description ?? toolDesc?.description ?? `Run ${name}`;
+
+		const cmd = parent.command(name).description(description);
+
+		// Add arguments
+		if (toolWrapper?.arguments) {
+			for (const arg of toolWrapper.arguments) {
+				const variadic = arg.variadic ? '...' : '';
+				const spec = arg.required ? `<${arg.name}${variadic}>` : `[${arg.name}${variadic}]`;
+				cmd.argument(spec, arg.description ?? arg.name);
+			}
+		}
+
+		// Add options
+		if (toolWrapper?.options) {
+			for (const opt of toolWrapper.options) {
+				// Note: In Commander.js, choices must be added as part of addOption(), not chained
+				if (opt.choices && opt.choices.length > 0) {
+					const { Option } = await import('commander');
+					const option = new Option(opt.flags, opt.description ?? opt.toolParam);
+					if (opt.default !== undefined) option.default(opt.default);
+					option.choices(opt.choices);
+					cmd.addOption(option);
+				} else {
+					cmd.option(opt.flags, opt.description ?? opt.toolParam, opt.default as string);
+				}
+			}
+		}
+
+		// Add output format option (avoid clashing with global --format)
+		const outputCfg = toolWrapper?.output ?? { format: 'raw' as const };
+		cmd.option('--output-format <format>', 'Output format', outputCfg.format);
+
+		cmd.action(async (...args: unknown[]) => {
+			const opts = args.pop() as Record<string, unknown>;
+			const posArgs = args as unknown[];
+
+			// Build tool input
+			const input: Record<string, unknown> = {};
+
+			if (toolWrapper?.arguments) {
+				toolWrapper.arguments.forEach((arg: (typeof toolWrapper.arguments)[number], i: number) => {
+					if (i < posArgs.length) {
+						input[arg.toolParam] = posArgs[i];
+					}
+				});
+			}
+
+			if (toolWrapper?.options) {
+				for (const opt of toolWrapper.options) {
+					const optName = this.extractOptionName(opt.flags);
+					if (opts[optName] !== undefined) {
+						input[opt.toolParam] = opts[optName];
+					}
+				}
+			}
+
+			// Execute tool
+			const tool = await this.runtime.resolve<ToolImplementation>(target.kind, target.id);
+			const logger = await this.runtime.resolve<LoggerImplementation>('logging/logger', 'cli');
+			const toolCallCtx: ToolCallContext = {
+				callId: `cli:${target.id}:${Date.now()}`,
+				logger: logger.child(target.id)
+			};
+
+			const result = await tool.execute(input, this.runtime, toolCallCtx);
+
+			this.output(
+				result,
+				String(opts.outputFormat ?? outputCfg.format),
+				context,
+				outputCfg.extractField
+			);
+		});
+	}
+
+	private extractOptionName(flags: string): string {
+		const long = flags.match(/--(\w[\w-]*)/);
+		if (long) return long[1].replace(/-([a-z])/g, (_, c) => c.toUpperCase());
+		const short = flags.match(/-(\w)/);
+		if (short) return short[1];
+		throw new Error(`Cannot extract option name from: ${flags}`);
+	}
+
+	private output(data: unknown, format: string, ctx: CommandContext, extractField?: string): void {
+		let output = data;
+		if (extractField && typeof data === 'object' && data !== null) {
+			output = (data as Record<string, unknown>)[extractField] ?? data;
+		}
+
+		if (!ctx.ui) {
+			if (format === 'raw' && typeof output === 'string') {
+				process.stdout.write(`${output}\n`);
+			} else {
+				process.stdout.write(`${JSON.stringify(output, null, 2)}\n`);
+			}
+			return;
+		}
+
+		switch (format) {
+			case 'raw':
+				if (typeof output === 'string') {
+					process.stdout.write(`${output}\n`);
+				} else {
+					ctx.ui.json(output);
+				}
+				break;
+			case 'json':
+				ctx.ui.json(output);
+				break;
+			case 'yaml':
+				ctx.ui.yaml(output);
+				break;
+			case 'table':
+				if (Array.isArray(output)) {
+					ctx.ui.table(output);
+				} else {
+					ctx.ui.yaml(output);
+				}
+				break;
+			default:
+				ctx.ui.json(output);
+		}
+	}
+}