@vibesdotdev/cli 0.0.1

package/src/commands/profile/profile.delete.impl.ts

@@ -0,0 +1,71 @@
+/**
+ * Profile Delete Implementation
+ *
+ * Deletes a profile directory with optional --force to skip confirmation.
+ * Refuses to delete the currently active profile.
+ */
+
+import { createInterface } from 'node:readline/promises';
+import {
+	getActiveProfile,
+	profileExists,
+	deleteProfileDir,
+	validateProfileName,
+	GREEN,
+	RED,
+	BOLD,
+	RESET,
+	log
+} from './_utils';
+
+export default {
+	async execute(
+		args: Record<string, unknown>,
+		opts: Record<string, unknown>
+	): Promise<void> {
+		const name = args.name as string;
+		const force = opts.force === true;
+
+		if (!name) {
+			log(`${RED}✗${RESET} Profile name is required`);
+			process.exit(1);
+		}
+
+		validateProfileName(name);
+
+		log('');
+		log(`${BOLD}vibes profile delete${RESET} ${name}`);
+		log(`${'─'.repeat(40)}`);
+
+		if (!profileExists(name)) {
+			log(`  ${RED}✗${RESET} Profile does not exist: ${BOLD}${name}${RESET}`);
+			log('');
+			process.exit(1);
+		}
+
+		const active = getActiveProfile();
+		if (name === active) {
+			log(`  ${RED}✗${RESET} Cannot delete the currently active profile: ${BOLD}${name}${RESET}`);
+			log('');
+			process.exit(1);
+		}
+
+		if (!force) {
+			const rl = createInterface({
+				input: process.stdin,
+				output: process.stdout
+			});
+			const answer = await rl.question(`  Delete profile "${name}"? [y/N] `);
+			rl.close();
+			if (answer.trim().toLowerCase() !== 'y') {
+				log(`  ${RED}✗${RESET} Cancelled`);
+				log('');
+				return;
+			}
+		}
+
+		deleteProfileDir(name);
+		log(`  ${GREEN}✓${RESET} Deleted profile ${BOLD}${name}${RESET}`);
+		log('');
+	}
+};

package/src/commands/profile/profile.info.descriptor.ts

@@ -0,0 +1,25 @@
+import type { CLICommandAssetDescriptor } from '../../schemas/descriptors';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'profile.info',
+	name: 'info',
+	description: 'Show profile information',
+	group: 'profile',
+	arguments: [
+		{
+			name: 'name',
+			description: 'Profile name (defaults to active profile)',
+			required: false
+		}
+	],
+	examples: [
+		{ command: 'vibes profile info', description: 'Show info for the active profile' },
+		{ command: 'vibes profile info work', description: 'Show info for the "work" profile' }
+	],
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

package/src/commands/profile/profile.info.impl.ts

@@ -0,0 +1,51 @@
+/**
+ * Profile Info Implementation
+ *
+ * Shows details about a specific profile or the active one.
+ */
+
+import { existsSync } from 'node:fs';
+import { join } from 'node:path';
+import {
+	getProfilesDir,
+	getActiveProfile,
+	profileExists,
+	validateProfileName,
+	GREEN,
+	RED,
+	GRAY,
+	BOLD,
+	RESET,
+	log
+} from './_utils';
+
+export default {
+	async execute(args: Record<string, unknown>): Promise<void> {
+		const name = (args.name as string | undefined) ?? getActiveProfile();
+
+		log('');
+		log(`${BOLD}vibes profile info${RESET}`);
+		log(`${'─'.repeat(40)}`);
+
+		if (!name) {
+			log(`  ${GRAY}No active profile${RESET}`);
+			log('');
+			return;
+		}
+
+		validateProfileName(name);
+
+		const dir = getProfilesDir();
+		const path = join(dir, name);
+		const exists = profileExists(name);
+		const active = getActiveProfile();
+		const isActive = name === active;
+
+		log(`  Name:     ${BOLD}${name}${RESET}`);
+		log(`  Path:     ${GRAY}${path}${RESET}`);
+		log(`  Exists:   ${exists ? `${GREEN}✓${RESET} yes` : `${RED}✗${RESET} no`}`);
+		log(`  Active:   ${isActive ? `${GREEN}✓${RESET} yes` : `${GRAY}no${RESET}`}`);
+
+		log('');
+	}
+};

package/src/commands/profile/profile.list.descriptor.ts

@@ -0,0 +1,18 @@
+import type { CLICommandAssetDescriptor } from '../../schemas/descriptors';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'profile.list',
+	name: 'list',
+	description: 'List all profiles',
+	group: 'profile',
+	arguments: [],
+	examples: [
+		{ command: 'vibes profile list', description: 'Show all profiles with active indicator' }
+	],
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

package/src/commands/profile/profile.list.impl.ts

@@ -0,0 +1,46 @@
+/**
+ * Profile List Implementation
+ *
+ * Scans ~/.vibes/profile/ and lists each profile, highlighting the active one.
+ */
+
+import { existsSync } from 'node:fs';
+import {
+	getProfilesDir,
+	getActiveProfile,
+	listProfiles,
+	GREEN,
+	GRAY,
+	BOLD,
+	RESET,
+	log
+} from './_utils';
+
+export default {
+	async execute(): Promise<void> {
+		const dir = getProfilesDir();
+		const active = getActiveProfile();
+
+		log('');
+		log(`${BOLD}vibes profile list${RESET}`);
+		log(`${'─'.repeat(40)}`);
+
+		if (!existsSync(dir)) {
+			log(`  ${GRAY}~/.vibes/profile/ does not exist${RESET}`);
+			log('');
+			return;
+		}
+
+		const profiles = listProfiles();
+		if (profiles.length === 0) {
+			log(`  ${GRAY}No profiles found${RESET}`);
+		} else {
+			for (const name of profiles) {
+				const marker = name === active ? ` ${GREEN}[active]${RESET}` : '';
+				log(`  ${GREEN}✓${RESET} ${name}${marker}`);
+			}
+		}
+
+		log('');
+	}
+};

package/src/commands/profile/profile.use.descriptor.ts

@@ -0,0 +1,25 @@
+import type { CLICommandAssetDescriptor } from '../../schemas/descriptors';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'profile.use',
+	name: 'use',
+	description: 'Print shell export statement to activate a profile',
+	group: 'profile',
+	arguments: [
+		{
+			name: 'name',
+			description: 'Name of the profile to activate',
+			required: true
+		}
+	],
+	examples: [
+		{ command: 'vibes profile use work', description: 'Print export for the "work" profile' },
+		{ command: 'eval "$(vibes profile use work)"', description: 'Activate profile in current shell' }
+	],
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

package/src/commands/profile/profile.use.impl.ts

@@ -0,0 +1,39 @@
+/**
+ * Profile Use Implementation
+ *
+ * Prints the shell export statement for activating a profile.
+ */
+
+import {
+	profileExists,
+	validateProfileName,
+	GREEN,
+	RED,
+	GRAY,
+	BOLD,
+	RESET,
+	log
+} from './_utils';
+
+export default {
+	async execute(args: Record<string, unknown>): Promise<void> {
+		const name = args.name as string;
+		if (!name) {
+			log(`${RED}✗${RESET} Profile name is required`);
+			process.exit(1);
+		}
+
+		validateProfileName(name);
+
+		if (!profileExists(name)) {
+			log(`${RED}✗${RESET} Profile does not exist: ${BOLD}${name}${RESET}`);
+			process.exit(1);
+		}
+
+		process.stdout.write(`export VIBES_PROFILE=${name}\n`);
+		process.stderr.write(
+			`\n${GRAY}# Add this to your shell rc file to make it persistent:${RESET}\n` +
+			`${GRAY}# echo 'export VIBES_PROFILE=${name}' >> ~/.zshrc${RESET}\n`
+		);
+	}
+};

package/src/commands/runtime/_logging.ts

@@ -0,0 +1,47 @@
+import { createRuntimeLogger } from '@vibesdotdev/logging/core';
+
+export function createRuntimeCliLogger(command: string) {
+	return createRuntimeLogger({
+		namespace: `runtime.cli.${command}`,
+		runtime: 'cli',
+		staticMetadata: {
+			service: 'runtime-cli',
+			command
+		}
+	});
+}
+
+export function formatError(error: unknown): { error: string; stack?: string } {
+	if (error instanceof Error) {
+		return {
+			error: error.message,
+			...(error.stack ? { stack: error.stack } : {})
+		};
+	}
+
+	return { error: String(error) };
+}
+
+export function formatCliOutput(message: string): void {
+	process.stdout.write(`${message}\n`);
+}
+
+export function formatCliError(message: string): void {
+	process.stderr.write(`${message}\n`);
+}
+
+export function formatCliDetail(id: string, issue: string): void {
+	formatCliOutput(`           - ${id}: ${issue}`);
+}
+
+export function formatCliSection(title: string): void {
+	formatCliOutput('');
+	formatCliOutput(title);
+	formatCliOutput('-'.repeat(title.length));
+}
+
+export function formatCliSubsection(title: string): void {
+	formatCliOutput('');
+	formatCliOutput(`  ${title}`);
+	formatCliOutput('  ' + '-'.repeat(title.length));
+}

package/src/commands/runtime/codegen.command.descriptor.ts

@@ -0,0 +1,18 @@
+import { createRuntimeAsset } from '@vibesdotdev/runtime';
+
+export const runtimeCodegenCommandDescriptor = createRuntimeAsset({
+	id: 'runtime-codegen',
+	kind: 'cli/command',
+	name: 'codegen',
+	description: 'Generate static runtime loader for compiled binaries',
+	group: 'runtime',
+	arguments: [],
+	options: [
+		{
+			name: 'verbose',
+			description: 'Enable verbose logging',
+			type: 'boolean',
+			short: 'v'
+		}
+	]
+});

package/src/commands/runtime/codegen.command.impl.ts

@@ -0,0 +1,44 @@
+import { createRuntimeImplementation } from '@vibesdotdev/runtime';
+import type { Command } from 'commander';
+import type { RuntimeContext } from '../../core/runtime/context.ts';
+import { generate } from './codegen.ts';
+
+export const runtimeCodegenCommandImpl = createRuntimeImplementation({
+	id: 'runtime-codegen',
+	kind: 'cli/command',
+	implementation: {
+		execute: async (args: Record<string, unknown>, opts: Record<string, unknown>) => {
+			// Create a mock command and context for the registration function. The mock only
+			// needs to satisfy the chained shape that `generate()` invokes; widening through
+			// `unknown` keeps the cast explicit rather than relying on `any`.
+			const mockCommand = {
+				command: () => ({
+					description: () => ({
+						option: () => ({
+							action: (handler: () => Promise<void>) => handler()
+						})
+					})
+				})
+			} as unknown as Command;
+
+			const mockContext = {
+				ui: {
+					success: (msg: string) => process.stdout.write(`✅ ${msg}\n`),
+					error: (msg: string) => {
+						process.stderr.write(`❌ ${msg}\n`);
+						throw new Error(msg);
+					}
+				}
+			} as unknown as RuntimeContext;
+
+			try {
+				await generate();
+				mockContext.ui.success('Runtime codegen completed successfully');
+			} catch (error) {
+				mockContext.ui.error(
+					`Runtime codegen failed: ${error instanceof Error ? error.message : String(error)}`
+				);
+			}
+		}
+	}
+});

package/src/commands/runtime/codegen.ts

@@ -0,0 +1,84 @@
+#!/usr/bin/env bun
+/**
+ * Runtime Codegen Command
+ *
+ * Thin wrapper around the canonical runtime bundle codegen script.
+ * The script in /scripts is the single source of truth.
+ */
+
+import type { Command } from 'commander';
+import type { RuntimeContext } from '../../core/runtime/context.ts';
+import { join, resolve } from 'node:path';
+import { getLogger } from '../../logging.ts';
+
+const logger = getLogger('runtime-codegen');
+
+const ROOT_DIR = resolve(join(import.meta.dir, '../../../../../../'));
+const CODEGEN_SCRIPT = join(ROOT_DIR, 'scripts/codegen-runtime-bundle.ts');
+
+export interface RuntimeCodegenOptions {
+	scope?: string;
+	hardware?: string;
+	verbose?: boolean;
+}
+
+function resolveBunBinary(): string {
+	const whichBun = typeof Bun.which === 'function' ? Bun.which('bun') : null;
+	if (whichBun) return whichBun;
+	return process.execPath || 'bun';
+}
+
+async function runRuntimeCodegenScript(options: RuntimeCodegenOptions = {}): Promise<void> {
+	const scriptExists = await Bun.file(CODEGEN_SCRIPT).exists();
+	if (!scriptExists) {
+		throw new Error(`Runtime codegen script not found: ${CODEGEN_SCRIPT}`);
+	}
+
+	const args = [resolveBunBinary(), CODEGEN_SCRIPT];
+	if (options.scope) args.push(options.scope);
+	if (options.hardware) args.push(options.hardware);
+
+	const proc = Bun.spawn(args, {
+		cwd: ROOT_DIR,
+		stdout: 'inherit',
+		stderr: 'inherit',
+		stdin: 'inherit',
+		env: process.env
+	});
+
+	const exitCode = await proc.exited;
+	if (exitCode !== 0) {
+		throw new Error(`Runtime codegen script failed with exit code ${exitCode}`);
+	}
+}
+
+export async function generate(options: RuntimeCodegenOptions = {}): Promise<void> {
+	await runRuntimeCodegenScript(options);
+}
+
+export async function registerRuntimeCodegenCommand(
+	parent: Command,
+	context: RuntimeContext
+): Promise<void> {
+	parent
+		.command('codegen')
+		.description('Generate static runtime loader for compiled binaries')
+		.option('-v, --verbose', 'Enable verbose logging')
+		.option('--scope <scope>', 'Filter generated bundle by runtime surface scope')
+		.option('--hardware <hardware>', 'Filter generated bundle by runtime hardware')
+		.action(async (options: RuntimeCodegenOptions) => {
+			if (options.verbose) {
+				logger.info('Running runtime codegen script...');
+			}
+
+			try {
+				await generate(options);
+				context.ui.success('Runtime codegen completed successfully');
+			} catch (error) {
+				context.ui.error(
+					`Runtime codegen failed: ${error instanceof Error ? error.message : String(error)}`
+				);
+				process.exit(1);
+			}
+		});
+}

package/src/commands/runtime/index.ts

@@ -0,0 +1,14 @@
+import type { Command } from 'commander';
+import type { RuntimeContext } from '../../core/runtime/context.ts';
+import { registerRuntimeCodegenCommand } from './codegen.ts';
+
+export async function registerRuntimeCommands(
+	parent: Command,
+	context: RuntimeContext
+): Promise<void> {
+	// Create the runtime command group
+	const runtimeCmd = parent.command('runtime').description('Runtime management commands');
+
+	// Register the codegen subcommand
+	await registerRuntimeCodegenCommand(runtimeCmd, context);
+}

package/src/commands/runtime/plugin.ts

@@ -0,0 +1,7 @@
+import { createRuntimePlugin } from '@vibesdotdev/runtime';
+
+export const runtimeCliPlugin = createRuntimePlugin({
+	id: 'runtime-cli',
+	name: 'Runtime CLI Plugin',
+	description: 'Provides runtime management commands for the CLI'
+});

package/src/commands/runtime/runtime-group.descriptor.ts

@@ -0,0 +1,12 @@
+import type { CLIGroupAssetDescriptor } from '../../schemas/descriptors';
+
+const descriptor: CLIGroupAssetDescriptor = {
+	kind: 'cli/group',
+	id: 'runtime',
+	name: 'runtime',
+	description: 'Runtime management commands',
+	order: 50,
+	enabled: true
+};
+
+export default descriptor;

package/src/config.ts

@@ -0,0 +1,22 @@
+/**
+ * Shared CLI config contract for `vibes.config.ts`.
+ *
+ * Re-exports the canonical `VibesAppConfig` from `@vibesdotdev/runtime/config`
+ * and provides a typed `defineConfig` helper for editor autocomplete in
+ * project-level configs.
+ */
+
+export type { VibesAppConfig, PluginsConfig } from '@vibesdotdev/runtime/config';
+
+import type { VibesAppConfig } from '@vibesdotdev/runtime/config';
+
+/**
+ * Project config shape accepted by `defineConfig`. Plugin arrays may be
+ * empty, in which case the binary's `defaultPlugins` (statically imported
+ * by the wrapper) are used. Set this to override or extend that default.
+ */
+export type VibesConfig = Partial<VibesAppConfig>;
+
+export function defineConfig(config: VibesConfig): VibesConfig {
+	return config;
+}

package/src/core/index.ts

@@ -0,0 +1,9 @@
+/**
+ * CLI core compatibility barrel.
+ */
+
+export { getContext, setContext, type RuntimeContext } from './runtime/context.ts';
+export type { Hook } from './runtime/hooks.ts';
+export type { CLIContext } from '../providers.ts';
+export type { CLIRuntimeContext, UIToolkit, CommandLayout } from './plugins/types.ts';
+export type { IUIHandles } from './ui/interface.ts';

package/src/core/namespace/hook.ts

@@ -0,0 +1,25 @@
+/**
+ * Namespace Hook Compatibility API
+ *
+ * Legacy callers import register/get helpers from this module.
+ * It delegates to the compatibility namespace registry.
+ */
+
+import { getNamespaceRegistry } from './index';
+import type { NamespaceDefinition, ConfigValue } from './schemas';
+
+export async function registerNamespace(
+	_context: Record<string, ConfigValue>,
+	definition: NamespaceDefinition
+): Promise<void> {
+	getNamespaceRegistry().register(definition);
+}
+
+export function getNamespaceConfig<TConfig extends Record<string, ConfigValue>>(
+	_context: Record<string, ConfigValue>,
+	namespaceId: string
+) {
+	return getNamespaceRegistry().getConfig<TConfig>(namespaceId);
+}
+
+export { getNamespaceRegistry };