@vibesdotdev/cli 0.0.1 → 1.0.0-rc.2

package/src/patterns/process-manager.ts

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

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

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

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

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