@vibesdotdev/config 0.0.1

package/src/adapters/cli/index.ts

@@ -0,0 +1,24 @@
+/**
+ * CLI Config Adapter
+ */
+export { getCLIPromptType, CLI_PROMPT_MAP } from './mappings.ts';
+export type { CLIPromptType } from './mappings.ts';
+export {
+	formatFieldPrompt,
+	formatSelectOptions,
+	formatDefaultValue,
+	parseInputValue
+} from './prompts.ts';
+export type { PromptResult } from './prompts.ts';
+export { createWizardSteps, getStepPrompts, validateWizardResults } from './wizard.ts';
+export type { WizardOptions, WizardStep, WizardResult } from './wizard.ts';
+
+// Config flag helpers
+export {
+	parseConfigFlag,
+	parseConfigFlags,
+	createConfigFlagCollector,
+	validateConfigOverrideKeys,
+	formatConfigOverrides
+} from './flags.ts';
+export type { ConfigOverride, ParsedConfigFlag } from './flags.ts';

package/src/adapters/cli/mappings.ts

@@ -0,0 +1,43 @@
+/**
+ * CLI Prompt Mappings
+ *
+ * Maps FieldComponent types to CLI prompt types
+ */
+import type { FieldComponent } from '../../manifest/types.ts';
+
+import type { CLIPromptType } from './schemas/mappings.schema.ts';
+
+export type { CLIPromptType } from './schemas/mappings.schema.ts';
+
+/**
+ * Map field component to CLI prompt type
+ */
+export const CLI_PROMPT_MAP: Record<FieldComponent, CLIPromptType> = {
+	input: 'input',
+	textarea: 'input',
+	number: 'number',
+	select: 'select',
+	'multi-select': 'multiselect',
+	'radio-group': 'select',
+	checkbox: 'confirm',
+	switch: 'confirm',
+	slider: 'number',
+	color: 'input',
+	date: 'input',
+	datetime: 'input',
+	file: 'input',
+	password: 'password',
+	secret: 'password',
+	json: 'input',
+	code: 'input',
+	custom: 'input',
+	reference: 'select',
+	'multi-reference': 'multiselect'
+};
+
+/**
+ * Get CLI prompt type for a field
+ */
+export function getCLIPromptType(component: FieldComponent): CLIPromptType {
+	return CLI_PROMPT_MAP[component] || 'input';
+}

package/src/adapters/cli/prompts.ts

@@ -0,0 +1,70 @@
+/**
+ * CLI Prompt Utilities
+ *
+ * Functions for prompting users in CLI context
+ */
+import type { ConfigFieldMeta } from '../../manifest/types.ts';
+import type { ResolvedField } from '../../form/core/types.ts';
+import { getCLIPromptType } from './mappings.ts';
+
+export type { PromptResult } from './schemas/prompts.schema.ts';
+
+/**
+ * Format a field for CLI display
+ */
+export function formatFieldPrompt(field: ResolvedField): string {
+	const { meta } = field;
+	let prompt = meta.ui.label;
+
+	if (meta.ui.description) {
+		prompt += ` (${meta.ui.description})`;
+	}
+
+	if (field.required) {
+		prompt += ' *';
+	}
+
+	return prompt;
+}
+
+/**
+ * Format options for select prompts
+ */
+export function formatSelectOptions(
+	meta: ConfigFieldMeta
+): Array<{ value: string; label: string }> {
+	if (!meta.options) return [];
+
+	return meta.options.map((opt) => ({
+		value: String(opt.value),
+		label: opt.description ? `${opt.label} - ${opt.description}` : opt.label
+	}));
+}
+
+/**
+ * Get default value display for CLI
+ */
+export function formatDefaultValue(value: unknown): string {
+	if (value === undefined || value === null) return '';
+	if (typeof value === 'boolean') return value ? 'yes' : 'no';
+	if (typeof value === 'object') return JSON.stringify(value);
+	return String(value);
+}
+
+/**
+ * Parse CLI input to correct type
+ */
+export function parseInputValue(input: string, field: ResolvedField): unknown {
+	const promptType = getCLIPromptType(field.component);
+
+	switch (promptType) {
+		case 'number': {
+			const num = parseFloat(input);
+			return isNaN(num) ? undefined : num;
+		}
+		case 'confirm':
+			return input.toLowerCase() === 'yes' || input.toLowerCase() === 'y' || input === 'true';
+		default:
+			return input;
+	}
+}

package/src/adapters/cli/schemas/flags.schema.ts

@@ -0,0 +1,8 @@
+export type ConfigOverride = Record<string, unknown>;
+
+export interface ParsedConfigFlag {
+	config: ConfigOverride;
+	key: string;
+	rawValue: string;
+	value: unknown;
+}

package/src/adapters/cli/schemas/mappings.schema.ts

@@ -0,0 +1,3 @@
+import type { FieldComponent } from '../../../manifest/types.ts';
+
+export type CLIPromptType = 'input' | 'password' | 'number' | 'confirm' | 'select' | 'multiselect';

package/src/adapters/cli/schemas/prompts.schema.ts

@@ -0,0 +1,4 @@
+export interface PromptResult {
+	value: unknown;
+	skipped: boolean;
+}

package/src/adapters/cli/schemas/wizard.schema.ts

@@ -0,0 +1,21 @@
+import type { ConfigManifest, ConfigContext } from '../../../manifest/types.ts';
+import type { ResolvedField, ResolvedGroup } from '../../../form/core/types.ts';
+
+export interface WizardOptions {
+	manifest: ConfigManifest;
+	initialValues?: Record<string, unknown>;
+	context?: Partial<ConfigContext>;
+	skipOptional?: boolean;
+	showDescriptions?: boolean;
+}
+
+export interface WizardStep {
+	group: ResolvedGroup;
+	fields: ResolvedField[];
+}
+
+export interface WizardResult {
+	values: Record<string, unknown>;
+	completed: boolean;
+	skippedFields: string[];
+}

package/src/adapters/cli/wizard.ts

@@ -0,0 +1,106 @@
+/**
+ * Config Wizard
+ *
+ * Multi-step configuration wizard for CLI
+ */
+import type { ConfigManifest, ConfigContext } from '../../manifest/types.ts';
+import type { ResolvedField, ResolvedGroup } from '../../form/core/types.ts';
+import { resolveFields, getFieldDefault } from '../../form/core/field-resolver.ts';
+import {
+	isFieldVisible,
+	isFieldDisabled,
+	isFieldRequired
+} from '../../form/core/visibility.ts';
+import { resolveGroups } from '../../form/core/groups.ts';
+import { validateForm } from '../../form/core/validation.ts';
+import { formatFieldPrompt, formatSelectOptions, formatDefaultValue } from './prompts.ts';
+
+import type { WizardOptions, WizardStep } from './schemas/wizard.schema.ts';
+
+export type { WizardOptions, WizardStep, WizardResult } from './schemas/wizard.schema.ts';
+
+function createDefaultContext(partial?: Partial<ConfigContext>): ConfigContext {
+	return {
+		hardware: partial?.hardware ?? 'consumer',
+		environment: partial?.environment ?? 'development',
+		surface: 'cli',
+		isAuthenticated: partial?.isAuthenticated ?? false,
+		userRole: partial?.userRole,
+		enabledFeatures: partial?.enabledFeatures ?? new Set(),
+		get: () => undefined,
+		custom: partial?.custom ?? {}
+	};
+}
+
+/**
+ * Create wizard steps from manifest
+ */
+export function createWizardSteps(options: WizardOptions): WizardStep[] {
+	const { manifest, initialValues = {}, skipOptional = false } = options;
+	const context = createDefaultContext(options.context);
+
+	// Get initial values
+	const defaults: Record<string, unknown> = {};
+	for (const [key, meta] of Object.entries(manifest.fields)) {
+		defaults[key] = getFieldDefault(meta, context);
+	}
+	const values = { ...defaults, ...initialValues };
+
+	// Resolve fields
+	const fields = resolveFields(manifest, values, {}, context);
+
+	for (const field of fields) {
+		field.visible = isFieldVisible(field.meta, values, context);
+		field.disabled = isFieldDisabled(field.meta, values, context);
+		field.required = isFieldRequired(field.meta, values, context);
+	}
+
+	// Filter fields
+	const visibleFields = fields.filter((f) => {
+		if (!f.visible) return false;
+		if (f.disabled) return false;
+		if (skipOptional && !f.required) return false;
+		return true;
+	});
+
+	// Group into steps
+	const groups = resolveGroups(manifest, visibleFields, values, context);
+
+	return groups
+		.filter((g) => g.visible && g.fields.length > 0)
+		.map((group) => ({
+			group,
+			fields: group.fields
+		}));
+}
+
+/**
+ * Get field prompts for a wizard step
+ */
+export function getStepPrompts(step: WizardStep): Array<{
+	field: ResolvedField;
+	prompt: string;
+	options?: Array<{ value: string; label: string }>;
+	default?: string;
+}> {
+	return step.fields.map((field) => ({
+		field,
+		prompt: formatFieldPrompt(field),
+		options: field.meta.options ? formatSelectOptions(field.meta) : undefined,
+		default: formatDefaultValue(field.value)
+	}));
+}
+
+/**
+ * Validate wizard results
+ */
+export function validateWizardResults(
+	manifest: ConfigManifest,
+	values: Record<string, unknown>
+): { valid: boolean; errors: Record<string, string> } {
+	const result = validateForm(manifest, values);
+	return {
+		valid: result.valid,
+		errors: result.errors as Record<string, string>
+	};
+}