@vibesdotdev/cli 0.0.1

package/src/commands/completion/fig.ts

@@ -0,0 +1,78 @@
+/**
+ * Fig / Amazon Q Completion Spec Generator
+ *
+ * Generates a TypeScript completion spec compatible with:
+ * - Amazon Q Developer CLI (successor to Fig)
+ * - Inshellisense (Microsoft)
+ * - Warp terminal
+ * - @withfig/autocomplete ecosystem
+ */
+
+import type { CommandNode, OptionNode } from './tree';
+
+function optionToFig(opt: OptionNode): string {
+	const names: string[] = [];
+	if (opt.short) names.push(`"-${opt.short}"`);
+	names.push(`"--${opt.long}"`);
+	const nameStr = names.length === 1 ? names[0] : `[${names.join(', ')}]`;
+
+	const parts = [`            name: ${nameStr}`];
+	parts.push(`            description: ${JSON.stringify(opt.description)}`);
+	if (opt.takesValue) parts.push('            args: { name: "value" }');
+	if (opt.choices) {
+		const suggestions = opt.choices.map((c) => `"${c}"`).join(', ');
+		parts.push(`            args: { name: "value", suggestions: [${suggestions}] }`);
+	}
+
+	return `        {\n${parts.join(',\n')}\n        }`;
+}
+
+function nodeToFig(node: CommandNode, indent: number): string {
+	const pad = ' '.repeat(indent);
+	const parts: string[] = [];
+	parts.push(`${pad}{`);
+	parts.push(`${pad}    name: ${JSON.stringify(node.name)},`);
+	parts.push(`${pad}    description: ${JSON.stringify(node.description)},`);
+
+	if (node.children.length > 0) {
+		const childSpecs = node.children.map((c) => nodeToFig(c, indent + 4));
+		parts.push(`${pad}    subcommands: [`);
+		parts.push(childSpecs.join(',\n'));
+		parts.push(`${pad}    ],`);
+	}
+
+	if (node.options.length > 0) {
+		parts.push(`${pad}    options: [`);
+		parts.push(node.options.map(optionToFig).join(',\n'));
+		parts.push(`${pad}    ],`);
+	}
+
+	if (node.arguments.length > 0) {
+		const arg = node.arguments[0];
+		parts.push(`${pad}    args: {`);
+		parts.push(`${pad}        name: ${JSON.stringify(arg.name)},`);
+		parts.push(`${pad}        description: ${JSON.stringify(arg.description)},`);
+		if (!arg.required) parts.push(`${pad}        isOptional: true,`);
+		if (arg.variadic) parts.push(`${pad}        variadic: true,`);
+		parts.push(`${pad}    },`);
+	}
+
+	parts.push(`${pad}}`);
+	return parts.join('\n');
+}
+
+export function generateFigSpec(tree: CommandNode): string {
+	const lines: string[] = [
+		'// vibes Fig/Amazon Q completion spec — generated by vibes completion fig',
+		'//',
+		'// For Amazon Q CLI: save to ~/.fig/autocomplete/vibes.ts',
+		'// For Inshellisense: save to node_modules/@withfig/autocomplete/src/vibes.ts',
+		'',
+		`const completionSpec: Fig.Spec = ${nodeToFig(tree, 0)};`,
+		'',
+		'export default completionSpec;',
+		''
+	];
+
+	return lines.join('\n');
+}

package/src/commands/completion/fish.ts

@@ -0,0 +1,52 @@
+/**
+ * Fish Completion Generator
+ *
+ * Generates fish shell completions from the command tree.
+ */
+
+import type { CommandNode } from './tree';
+
+function emitNode(node: CommandNode, parentCondition: string): string[] {
+	const lines: string[] = [];
+
+	for (const child of node.children) {
+		const isGroup = child.children.length > 0;
+		lines.push(
+			`complete -c vibes -n "${parentCondition}" -a ${child.name} -d "${child.description}"`
+		);
+		for (const alias of child.aliases) {
+			lines.push(
+				`complete -c vibes -n "${parentCondition}" -a ${alias} -d "${child.description}"`
+			);
+		}
+
+		for (const opt of child.options) {
+			const condition = `__fish_seen_subcommand_from ${child.name}`;
+			const shortFlag = opt.short ? `-s ${opt.short} ` : '';
+			const reqArg = opt.takesValue ? '-r ' : '';
+			lines.push(
+				`complete -c vibes -n "${condition}" ${shortFlag}${reqArg}-l ${opt.long} -d "${opt.description}"`
+			);
+		}
+
+		if (isGroup) {
+			lines.push(...emitNode(child, `__fish_seen_subcommand_from ${child.name}`));
+		}
+	}
+
+	return lines;
+}
+
+export function generateFishCompletion(tree: CommandNode): string {
+	const lines = [
+		'# vibes fish completion — generated by vibes completion fish',
+		'# Save to ~/.config/fish/completions/vibes.fish',
+		'',
+		'# Disable file completions by default',
+		'complete -c vibes -f',
+		''
+	];
+
+	lines.push(...emitNode(tree, '__fish_use_subcommand'));
+	return lines.join('\n') + '\n';
+}

package/src/commands/completion/tree.ts

@@ -0,0 +1,115 @@
+/**
+ * Command Tree Builder
+ *
+ * Extracts the full CLI command tree from runtime descriptors.
+ * Used by shell completion generators to produce shell-specific output.
+ */
+
+import type { VibesRuntime } from '@vibesdotdev/runtime/api/runtime';
+import type {
+	CLICommandAssetDescriptor,
+	CLIGroupAssetDescriptor
+} from '../../schemas/descriptors';
+import { getCLIDiscovery, type CLIDiscoveryOptions } from '../../surface/discovery-cache';
+
+export interface CommandNode {
+	name: string;
+	description: string;
+	aliases: string[];
+	arguments: ArgumentNode[];
+	options: OptionNode[];
+	children: CommandNode[];
+}
+
+export interface ArgumentNode {
+	name: string;
+	description: string;
+	required: boolean;
+	variadic: boolean;
+	choices?: string[];
+}
+
+export interface OptionNode {
+	long: string;
+	short?: string;
+	description: string;
+	takesValue: boolean;
+	choices?: string[];
+	default?: unknown;
+}
+
+function parseFlags(flags: string): { long: string; short?: string; takesValue: boolean } {
+	const takesValue = flags.includes('<') || flags.includes('[');
+	const parts = flags.split(',').map((s) => s.trim().split(/\s/)[0]);
+	const long = parts.find((p) => p.startsWith('--'))?.replace(/^--/, '') ?? parts[0].replace(/^-/, '');
+	const short = parts.find((p) => p.startsWith('-') && !p.startsWith('--'))?.replace(/^-/, '');
+	return { long, short, takesValue };
+}
+
+export function buildCommandTree(
+	runtime: VibesRuntime,
+	options: CLIDiscoveryOptions = {}
+): CommandNode {
+	const discovery = getCLIDiscovery(runtime, options);
+	const groups = discovery.sortedGroups;
+	const commands = discovery.sortedCommands.filter((command) => command.id !== 'completion');
+
+	const groupNodes = new Map<string, CommandNode>();
+	for (const g of groups) {
+		groupNodes.set(g.id, {
+			name: g.name,
+			description: g.description ?? '',
+			aliases: g.aliases ?? [],
+			arguments: [],
+			options: [],
+			children: []
+		});
+	}
+
+	const root: CommandNode = {
+		name: 'vibes',
+		description: 'Vibes Developer CLI',
+		aliases: [],
+		arguments: [],
+		options: [
+			{ long: 'verbose', short: 'v', description: 'Enable verbose logging', takesValue: false },
+			{ long: 'help', short: 'h', description: 'Display help', takesValue: false }
+		],
+		children: []
+	};
+
+	for (const g of groups) {
+		const node = groupNodes.get(g.id);
+		if (!node) continue;
+		const parentNode = g.parent ? groupNodes.get(g.parent) : null;
+		(parentNode ?? root).children.push(node);
+	}
+
+	for (const cmd of commands) {
+		const node: CommandNode = {
+			name: cmd.name,
+			description: cmd.description ?? '',
+			aliases: cmd.aliases ?? [],
+			arguments: (cmd.arguments ?? []).map((a) => ({
+				name: a.name,
+				description: a.description ?? '',
+				required: a.required ?? false,
+				variadic: a.variadic ?? false
+			})),
+			options: (cmd.options ?? []).map((o) => {
+				const parsed = parseFlags(o.flags);
+				return {
+					...parsed,
+					description: o.description ?? '',
+					choices: o.choices,
+					default: o.default
+				};
+			}),
+			children: []
+		};
+		const parent = groupNodes.get(cmd.group);
+		(parent ?? root).children.push(node);
+	}
+
+	return root;
+}

package/src/commands/completion/zsh-widget.ts

@@ -0,0 +1,39 @@
+/**
+ * Zsh Autosuggestion Integration
+ *
+ * Registers a custom zsh-autosuggestions strategy that suggests
+ * vibes commands from known command paths. Falls back gracefully
+ * if zsh-autosuggestions is not installed.
+ *
+ * Uses the static _VIBES_SUGGEST_PATHS array (populated at generation
+ * time from runtime descriptors) — no subprocess calls, no external
+ * commands, no PATH dependencies.
+ */
+
+export function getWidgetCode(): string {
+	return `
+# ── zsh-autosuggestions integration ──
+# Registers a custom strategy for vibes commands.
+# If zsh-autosuggestions is not loaded, this is a no-op.
+
+_zsh_autosuggest_strategy_vibes() {
+    # Only handle vibes-prefixed input
+    [[ "\$1" != vibes* ]] && return
+
+    # Match against known command paths (no subprocess)
+    local _vp
+    for _vp in "\${_VIBES_SUGGEST_PATHS[@]}"; do
+        if [[ "vibes \$_vp" == "\$1"* && "vibes \$_vp" != "\$1" ]]; then
+            typeset -g suggestion="vibes \$_vp"
+            return
+        fi
+    done
+}
+
+# Prepend vibes strategy so it runs first for vibes commands,
+# then falls through to the default history strategy for everything else.
+if (( \$+functions[_zsh_autosuggest_strategy_history] )); then
+    ZSH_AUTOSUGGEST_STRATEGY=(vibes \${ZSH_AUTOSUGGEST_STRATEGY[@]})
+fi
+`.trim();
+}

package/src/commands/completion/zsh.ts

@@ -0,0 +1,165 @@
+/**
+ * Zsh Completion Generator
+ *
+ * Generates zsh tab completion with full flag/argument support
+ * and integrates with zsh-autosuggestions for inline ghost-text.
+ */
+
+import type { CommandNode, OptionNode, ArgumentNode } from './tree';
+import { getWidgetCode } from './zsh-widget';
+
+function esc(s: string): string {
+	return s.replace(/'/g, "'\\''").replace(/\[/g, '\\[').replace(/\]/g, '\\]');
+}
+
+function optionSpec(opt: OptionNode): string {
+	const desc = esc(opt.description);
+	const short = opt.short ? `-${opt.short}` : '';
+	const long = `--${opt.long}`;
+	const names = short ? `'(${short} ${long})'{${short},${long}}` : `${long}`;
+	const action = opt.choices
+		? `:(${opt.choices.join(' ')})`
+		: opt.takesValue
+			? `: :_default`
+			: '';
+	return `        ${names}'[${desc}]${action}'`;
+}
+
+function emitLeafFunction(node: CommandNode, fnName: string): string[] {
+	const lines: string[] = [];
+	lines.push(`${fnName}() {`);
+
+	if (node.options.length === 0 && node.arguments.length === 0) {
+		lines.push('    _message "no more arguments"');
+		lines.push('}');
+		return lines;
+	}
+
+	lines.push('    _arguments -s \\');
+	for (const opt of node.options) {
+		lines.push(optionSpec(opt) + ' \\');
+	}
+	for (const arg of node.arguments) {
+		const desc = esc(arg.description);
+		const action = arg.choices ? `(${arg.choices.join(' ')})` : '_default';
+		const spec = arg.variadic
+			? `'*:${desc}:${action}'`
+			: arg.required
+				? `':${desc}:${action}'`
+				: `'::${desc}:${action}'`;
+		lines.push(`        ${spec} \\`);
+	}
+	// Remove trailing backslash from last line
+	if (lines.length > 1) {
+		lines[lines.length - 1] = lines[lines.length - 1].replace(/ \\$/, '');
+	}
+	lines.push('}');
+	return lines;
+}
+
+function emitGroupFunction(node: CommandNode, fnName: string): string[] {
+	const lines: string[] = [];
+	lines.push(`${fnName}() {`);
+	lines.push('    local line state');
+	lines.push('    _arguments -C \\');
+
+	for (const opt of node.options) {
+		lines.push(optionSpec(opt) + ' \\');
+	}
+
+	lines.push(`        "1: :${fnName}_cmds" \\`);
+	lines.push('        "*::arg:->args"');
+	lines.push('    case "$state" in');
+	lines.push('        args)');
+	lines.push('            case "$line[1]" in');
+	for (const child of node.children) {
+		const childFn = `${fnName}_${child.name.replace(/-/g, '_')}`;
+		lines.push(`                ${child.name}) ${childFn} ;;`);
+		for (const alias of child.aliases) {
+			lines.push(`                ${alias}) ${childFn} ;;`);
+		}
+	}
+	lines.push('            esac');
+	lines.push('        ;;');
+	lines.push('    esac');
+	lines.push('}');
+	lines.push('');
+
+	// Subcommand list function
+	lines.push(`${fnName}_cmds() {`);
+	lines.push('    local -a subcmds');
+	lines.push('    subcmds=(');
+	for (const child of node.children) {
+		const desc = esc(child.description);
+		lines.push(`        '${child.name}:${desc}'`);
+		for (const alias of child.aliases) {
+			lines.push(`        '${alias}:${desc}'`);
+		}
+	}
+	lines.push('    )');
+	lines.push("    _describe -t commands 'commands' subcmds");
+	lines.push('}');
+
+	return lines;
+}
+
+function emitAll(node: CommandNode, fnName: string): string[] {
+	const lines: string[] = [];
+
+	if (node.children.length > 0) {
+		lines.push(...emitGroupFunction(node, fnName));
+		lines.push('');
+		for (const child of node.children) {
+			const childFn = `${fnName}_${child.name.replace(/-/g, '_')}`;
+			lines.push(...emitAll(child, childFn));
+			lines.push('');
+		}
+	} else {
+		lines.push(...emitLeafFunction(node, fnName));
+	}
+
+	return lines;
+}
+
+function collectPaths(node: CommandNode, prefix: string): string[] {
+	const results: string[] = [];
+	for (const child of node.children) {
+		const cp = prefix ? `${prefix} ${child.name}` : child.name;
+		results.push(cp);
+		for (const alias of child.aliases) {
+			results.push(prefix ? `${prefix} ${alias}` : alias);
+		}
+		if (child.children.length > 0) {
+			results.push(...collectPaths(child, cp));
+		}
+	}
+	return results;
+}
+
+export function generateZshCompletion(tree: CommandNode): string {
+	const completionPaths = collectPaths(tree, '').sort();
+	const completionPathsStr = completionPaths.map((p) => `    "${p}"`).join('\n');
+
+	const parts: string[] = [
+		'#compdef vibes',
+		'# vibes zsh completion — generated by vibes completion zsh',
+		'# Install: vibes completion zsh --install',
+		'',
+		'# ── Tab Completion (commands, flags, arguments) ──',
+		''
+	];
+
+	parts.push(...emitAll(tree, '_vibes'));
+	parts.push('');
+	parts.push('compdef _vibes vibes');
+	parts.push('');
+
+	parts.push('# ── Autosuggestion paths (used by zsh-autosuggestions strategy) ──');
+	parts.push('typeset -ga _VIBES_SUGGEST_PATHS=(');
+	parts.push(completionPathsStr);
+	parts.push(')');
+	parts.push('');
+	parts.push(getWidgetCode());
+
+	return parts.join('\n') + '\n';
+}

package/src/commands/profile/_utils.ts

@@ -0,0 +1,72 @@
+/**
+ * Profile command utilities
+ *
+ * Shared helpers for scanning profile directories and formatting output.
+ * Uses node built-ins only to avoid circular dependencies.
+ */
+
+import { existsSync, readdirSync, statSync, mkdirSync, rmSync } from 'node:fs';
+import { homedir } from 'node:os';
+import { join } from 'node:path';
+import { getRuntimeEnv } from '@vibesdotdev/runtime';
+
+export const GREEN = '\x1b[32m';
+export const GRAY = '\x1b[90m';
+export const YELLOW = '\x1b[33m';
+export const RED = '\x1b[31m';
+export const BOLD = '\x1b[1m';
+export const RESET = '\x1b[0m';
+
+const VALID_PROFILE_NAME = /^[a-zA-Z0-9._-]+$/;
+
+export function validateProfileName(name: string): string {
+	if (!name || typeof name !== 'string') {
+		throw new Error('Profile name is required');
+	}
+	if (name.length > 64) {
+		throw new Error('Profile name must be 64 characters or fewer');
+	}
+	if (!VALID_PROFILE_NAME.test(name)) {
+		throw new Error(
+			'Profile name may only contain letters, numbers, dots, hyphens, and underscores'
+		);
+	}
+	return name;
+}
+
+export function getProfilesDir(): string {
+	return join(homedir(), '.vibes', 'profile');
+}
+
+export function getActiveProfile(): string | undefined {
+	return getRuntimeEnv('VIBES_PROFILE') || getRuntimeEnv('VIBES_PROFILE_NAME') || undefined;
+}
+
+export function listProfiles(): string[] {
+	const dir = getProfilesDir();
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir).filter((name) => {
+		const full = join(dir, name);
+		return statSync(full).isDirectory();
+	});
+}
+
+export function profileExists(name: string): boolean {
+	const path = join(getProfilesDir(), name);
+	return existsSync(path) && statSync(path).isDirectory();
+}
+
+export function createProfileDir(name: string): void {
+	const base = join(getProfilesDir(), name);
+	for (const sub of ['config', 'data', 'cache', 'logs']) {
+		mkdirSync(join(base, sub), { recursive: true });
+	}
+}
+
+export function deleteProfileDir(name: string): void {
+	rmSync(join(getProfilesDir(), name), { recursive: true, force: true });
+}
+
+export function log(msg: string): void {
+	process.stderr.write(msg + '\n');
+}

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

@@ -0,0 +1,14 @@
+import type { CLIGroupAssetDescriptor } from '../../schemas/descriptors';
+
+const descriptor: CLIGroupAssetDescriptor = {
+	kind: 'cli/group',
+	id: 'profile',
+	name: 'profile',
+	description: 'Manage vibes profiles (isolated config/data environments)',
+	order: 100,
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

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

@@ -0,0 +1,24 @@
+import type { CLICommandAssetDescriptor } from '../../schemas/descriptors';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'profile.create',
+	name: 'create',
+	description: 'Create a new profile',
+	group: 'profile',
+	arguments: [
+		{
+			name: 'name',
+			description: 'Name of the profile to create',
+			required: true
+		}
+	],
+	examples: [
+		{ command: 'vibes profile create work', description: 'Create a new profile named "work"' }
+	],
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;

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

@@ -0,0 +1,44 @@
+/**
+ * Profile Create Implementation
+ *
+ * Creates ~/.vibes/profile/{name}/ along with config/, data/, cache/, logs/.
+ */
+
+import { existsSync } from 'node:fs';
+import {
+	getProfilesDir,
+	profileExists,
+	createProfileDir,
+	validateProfileName,
+	GREEN,
+	RED,
+	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);
+
+		log('');
+		log(`${BOLD}vibes profile create${RESET} ${name}`);
+		log(`${'─'.repeat(40)}`);
+
+		if (profileExists(name)) {
+			log(`  ${RED}✗${RESET} Profile already exists: ${BOLD}${name}${RESET}`);
+			log('');
+			process.exit(1);
+		}
+
+		createProfileDir(name);
+		log(`  ${GREEN}✓${RESET} Created profile ${BOLD}${name}${RESET}`);
+		log('');
+	}
+};

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

@@ -0,0 +1,31 @@
+import type { CLICommandAssetDescriptor } from '../../schemas/descriptors';
+
+const descriptor: CLICommandAssetDescriptor = {
+	kind: 'cli/command',
+	id: 'profile.delete',
+	name: 'delete',
+	description: 'Delete a profile',
+	group: 'profile',
+	arguments: [
+		{
+			name: 'name',
+			description: 'Name of the profile to delete',
+			required: true
+		}
+	],
+	options: [
+		{
+			flags: '--force',
+			description: 'Skip confirmation prompt'
+		}
+	],
+	examples: [
+		{ command: 'vibes profile delete work', description: 'Delete the "work" profile with confirmation' },
+		{ command: 'vibes profile delete work --force', description: 'Delete without confirmation' }
+	],
+	surfaces: ['cli'],
+	hardware: ['consumer'],
+	enabled: true
+};
+
+export default descriptor;