@vibesdotdev/config 0.0.1

package/src/schema/schemas/references.schema.ts

@@ -0,0 +1,86 @@
+export type ReferenceSource =
+	| ConfigReference
+	| NestedReference
+	| ComputedReference
+	| EnumReference;
+
+export interface ConfigReference {
+	type: 'config';
+	path: string;
+	valueField?: string;
+	labelField?: string;
+	descriptionField?: string;
+	iconField?: string;
+	filter?: string | ((item: unknown) => boolean);
+}
+
+export interface NestedReference {
+	type: 'nested';
+	parentPath: string;
+	parentField: string;
+	nestedPath: string;
+	valueField?: string;
+	labelField?: string;
+	descriptionField?: string;
+}
+
+export interface ComputedReference {
+	type: 'computed';
+	resolver: string;
+	dependsOn?: string[];
+	cacheDuration?: number;
+}
+
+export interface EnumReference {
+	type: 'enum';
+	values: Array<{
+		value: string;
+		label?: string;
+		description?: string;
+		icon?: string;
+	}>;
+}
+
+export interface EmptyStateConfig {
+	message: string;
+	createAction?: {
+		label: string;
+		route?: string;
+		inline?: boolean;
+		manifestId?: string;
+	};
+}
+
+export interface ReferenceMeta {
+	source: ReferenceSource;
+	as?: 'select' | 'radio' | 'combobox' | 'autocomplete';
+	multiple?: boolean;
+	emptyState?: EmptyStateConfig;
+	placeholder?: string;
+}
+
+export interface ResolvedOption {
+	value: string;
+	label: string;
+	description?: string;
+	icon?: string;
+	disabled?: boolean;
+}
+
+export interface ResolutionResult {
+	options: ResolvedOption[];
+	isLoading: boolean;
+	error?: string;
+	isEmpty: boolean;
+}
+
+export interface ResolutionContext {
+	getConfig: <T = unknown>(path: string) => T | undefined;
+	formValues: Record<string, unknown>;
+	runtimeContext: Record<string, unknown>;
+}
+
+export type ComputedResolverFn = (
+	dependencyValues: Record<string, unknown>,
+	context: ResolutionContext
+) => Promise<ResolvedOption[]>;

package/src/schemas/collection.ts

@@ -0,0 +1,38 @@
+/**
+ * Config Collection Descriptor Schema
+ *
+ * A config/collection groups related config manifests into a named
+ * collection with unified load/subscribe/dispose lifecycle.
+ */
+
+import * as z from 'zod/v4';
+
+/**
+ * Descriptor schema for config/collection kind.
+ */
+export const ConfigCollectionDescriptorSchema = z.object({
+	kind: z.literal('config/collection'),
+	id: z.string().min(1),
+	name: z.string().optional(),
+	description: z.string().optional(),
+	/** Manifest IDs this collection groups */
+	manifests: z.array(z.string().min(1)).min(1),
+	tags: z.array(z.string()).optional(),
+	hardware: z.array(z.string()).optional(),
+	enabled: z.boolean().optional()
+});
+
+export type ConfigCollectionDescriptor = z.infer<typeof ConfigCollectionDescriptorSchema>;
+
+// Collection Runtime Types
+
+type ManifestData = Record<string, unknown> | null;
+
+export interface CollectionState {
+	/** Loaded data keyed by manifest ID */
+	data: Record<string, ManifestData>;
+	/** Manifest IDs that failed to resolve */
+	errors: string[];
+}
+
+export type CollectionCallback = (state: CollectionState) => void;

package/src/schemas/config-manifest-descriptor.ts

@@ -0,0 +1,259 @@
+/**
+ * Config Manifest Descriptor Schema
+ *
+ * Extends StorageManifestDescriptor with config-specific metadata
+ * for form rendering, navigation, and UI behavior.
+ */
+
+import * as z from 'zod/v4';
+import { StorageManifestDescriptorSchema } from '@vibesdotdev/storage/schemas';
+
+// Config-Specific Types
+
+/**
+ * Configuration tiers determine storage location, visibility, and access patterns
+ */
+export const ConfigTierSchema = z.enum(['system', 'user', 'internal']);
+export type ConfigTier = z.infer<typeof ConfigTierSchema>;
+
+/**
+ * UI surfaces that can render configuration forms
+ */
+export const ConfigSurfaceSchema = z.enum(['tui', 'cli', 'web', 'bridge']);
+export type ConfigSurface = z.infer<typeof ConfigSurfaceSchema>;
+
+/**
+ * Hardware context for context-aware defaults
+ */
+export const HardwareContextSchema = z.enum(['cloud', 'consumer', 'gpu', 'cpu-only']);
+export type HardwareContext = z.infer<typeof HardwareContextSchema>;
+
+/**
+ * Environment context
+ */
+export const EnvironmentContextSchema = z.enum(['development', 'staging', 'production']);
+export type EnvironmentContext = z.infer<typeof EnvironmentContextSchema>;
+
+/**
+ * UI component types for rendering fields
+ */
+export const FieldComponentSchema = z.enum([
+	'input',
+	'textarea',
+	'number',
+	'select',
+	'multi-select',
+	'radio-group',
+	'checkbox',
+	'switch',
+	'slider',
+	'color',
+	'date',
+	'datetime',
+	'file',
+	'password',
+	'secret',
+	'json',
+	'code',
+	'reference',
+	'multi-reference',
+	'custom',
+	'list'
+]);
+export type FieldComponent = z.infer<typeof FieldComponentSchema>;
+
+/**
+ * Field width in form layout
+ */
+export const FieldWidthSchema = z.enum(['full', 'half', 'third', 'quarter']);
+export type FieldWidth = z.infer<typeof FieldWidthSchema>;
+
+// Field Metadata Schemas
+
+/**
+ * UI configuration for a field
+ */
+export const FieldUISchema = z.object({
+	label: z.string(),
+	description: z.string().optional(),
+	helpText: z.string().optional(),
+	placeholder: z.string().optional(),
+	icon: z.string().optional(),
+	component: FieldComponentSchema.optional(),
+	customComponent: z.string().optional(),
+	order: z.number().optional(),
+	group: z.string().optional(),
+	width: FieldWidthSchema.optional(),
+	hideLabel: z.boolean().optional(),
+	className: z.string().optional()
+});
+export type FieldUI = z.infer<typeof FieldUISchema>;
+
+/**
+ * Field option for enum/select fields
+ */
+export const FieldOptionSchema = z.object({
+	value: z.unknown(),
+	label: z.string(),
+	description: z.string().optional(),
+	icon: z.string().optional()
+	// disabledWhen and hiddenWhen use ConfigRule which is complex - keep as unknown
+});
+export type FieldOption = z.infer<typeof FieldOptionSchema>;
+
+/**
+ * Reference field configuration
+ */
+export const ReferenceConfigSchema = z.object({
+	entity: z.string(),
+	valueField: z.string().default('id'),
+	labelField: z.string().default('name'),
+	descriptionField: z.string().optional(),
+	endpoint: z.string().optional(),
+	filter: z.record(z.string(), z.unknown()).optional(),
+	dynamicFilter: z.record(z.string(), z.string()).optional(),
+	allowCreate: z.boolean().optional(),
+	orderable: z.boolean().optional(),
+	maxItems: z.number().optional(),
+	minItems: z.number().optional(),
+	customRenderer: z.string().optional(),
+	customRendererProps: z.record(z.string(), z.unknown()).optional()
+});
+export type ReferenceConfig = z.infer<typeof ReferenceConfigSchema>;
+
+/**
+ * Field access control
+ */
+export const FieldAccessSchema = z.object({
+	isPublic: z.boolean().optional(),
+	isEditable: z.boolean().optional(),
+	requiredRole: z.string().optional(),
+	surfaces: z.array(ConfigSurfaceSchema).optional()
+});
+export type FieldAccess = z.infer<typeof FieldAccessSchema>;
+
+/**
+ * Complete field metadata
+ */
+export const ConfigFieldMetaSchema = z.object({
+	ui: FieldUISchema,
+	// Rules are complex with functions - keep as unknown for descriptor
+	rules: z.unknown().optional(),
+	// Defaults can contain resolvers - keep as unknown
+	defaults: z.unknown().optional(),
+	options: z.array(FieldOptionSchema).optional(),
+	reference: ReferenceConfigSchema.optional(),
+	access: FieldAccessSchema.optional(),
+	dependsOn: z.array(z.string()).optional(),
+	tags: z.array(z.string()).optional()
+});
+export type ConfigFieldMeta = z.infer<typeof ConfigFieldMetaSchema>;
+
+/**
+ * Field group for UI organization
+ */
+export const ConfigFieldGroupSchema = z.object({
+	id: z.string(),
+	label: z.string(),
+	description: z.string().optional(),
+	icon: z.string().optional(),
+	order: z.number().optional(),
+	collapsible: z.boolean().optional(),
+	defaultCollapsed: z.boolean().optional()
+	// visibleWhen uses ConfigRule - omit for descriptor
+});
+export type ConfigFieldGroup = z.infer<typeof ConfigFieldGroupSchema>;
+
+// Navigation Schema
+
+/**
+ * Navigation configuration for a manifest
+ */
+export const ManifestNavigationSchema = z.object({
+	page: z.string().nullable(),
+	section: z.string().optional(),
+	order: z.number().default(100),
+	showInGlobalSettings: z.boolean().optional(),
+	parent: z.string().optional(),
+	label: z.string().optional(),
+	icon: z.string().optional(),
+	tags: z.array(z.string()).optional(),
+	params: z.record(z.string(), z.string()).optional()
+});
+export type ManifestNavigation = z.infer<typeof ManifestNavigationSchema>;
+
+// Context Constraints Schema
+
+/**
+ * Constraints on when a manifest applies
+ */
+export const ManifestContextSchema = z.object({
+	hardware: z.array(HardwareContextSchema).optional(),
+	environment: z.array(EnvironmentContextSchema).optional(),
+	surfaces: z.array(ConfigSurfaceSchema).optional(),
+	requiredFeatures: z.array(z.string()).optional()
+});
+export type ManifestContext = z.infer<typeof ManifestContextSchema>;
+
+// Config Manifest Descriptor
+
+/**
+ * Config manifest descriptor extends storage manifest with form metadata.
+ *
+ * A config manifest is a storage manifest that:
+ * - Has form field metadata for UI rendering
+ * - Has navigation configuration for placement in settings
+ * - Has context constraints for conditional availability
+ * - Has a configuration tier (system, user, internal)
+ */
+export const ConfigManifestDescriptorSchema = StorageManifestDescriptorSchema.extend({
+	kind: z.literal('config/manifest'),
+
+	// Classification
+
+	/** Configuration tier */
+	tier: ConfigTierSchema,
+	/** Category within the tier (for organization) */
+	category: z.string().optional(),
+
+	// Field Metadata
+
+	/** Field metadata keyed by field path */
+	fields: z.record(z.string(), ConfigFieldMetaSchema),
+	/** Field groups for UI organization */
+	groups: z.array(ConfigFieldGroupSchema).optional(),
+
+	// Navigation
+
+	/** Navigation and UI placement configuration */
+	navigation: ManifestNavigationSchema.optional(),
+
+	// Config Files
+
+	/** Optional config file location(s) for loading config from project files */
+	configFiles: z
+		.union([
+			z.object({ pattern: z.string() }),
+			z.array(z.object({ pattern: z.string() }))
+		])
+		.optional(),
+
+	// Context
+
+	/** Context constraints for when this manifest applies */
+	context: ManifestContextSchema.optional(),
+
+	// Display
+
+	/** Icon (emoji or icon name) */
+	icon: z.string().optional()
+});
+
+export type ConfigManifestDescriptor = z.infer<typeof ConfigManifestDescriptorSchema>;
+
+/**
+ * Type guard for config manifest descriptor
+ */
+export function isConfigManifestDescriptor(value: unknown): value is ConfigManifestDescriptor {
+	return ConfigManifestDescriptorSchema.safeParse(value).success;
+}

package/src/schemas/config-registry-state.ts

@@ -0,0 +1,13 @@
+import type { ConfigManifestDescriptor } from '../schemas/config-manifest-descriptor.ts';
+
+export interface ConfigRegistryState {
+	manifests: ConfigManifestDescriptor[];
+	loaded: boolean;
+	error: string | null;
+}
+
+export const defaultConfigRegistryState: ConfigRegistryState = {
+	manifests: [],
+	loaded: false,
+	error: null
+};

package/src/schemas/doctor.schema.ts

@@ -0,0 +1,27 @@
+export type DiagnosticSeverity = 'error' | 'warning' | 'info';
+
+export interface DiagnosticIssue {
+	path: string;
+	message: string;
+	severity: DiagnosticSeverity;
+	code?: string;
+}
+
+export interface DetailedDiagnostic {
+	ready: boolean;
+	issues: DiagnosticIssue[];
+	summary: {
+		errors: number;
+		warnings: number;
+		info: number;
+	};
+}
+
+export interface DiagnoseConfigOptions {
+	checkDeprecated?: boolean;
+	checkEndpoints?: boolean;
+	customValidators?: Array<{
+		path: string;
+		fn: (value: unknown) => string | null;
+	}>;
+}

package/src/schemas/index.ts

@@ -0,0 +1,53 @@
+/**
+ * Config Module Schemas
+ *
+ * Runtime-compatible schemas for config manifest descriptors.
+ */
+
+export {
+	// Main descriptor
+	ConfigManifestDescriptorSchema,
+	type ConfigManifestDescriptor,
+	isConfigManifestDescriptor,
+
+	// Classification
+	ConfigTierSchema,
+	type ConfigTier,
+	ConfigSurfaceSchema,
+	type ConfigSurface,
+	HardwareContextSchema,
+	type HardwareContext,
+	EnvironmentContextSchema,
+	type EnvironmentContext,
+
+	// Field components
+	FieldComponentSchema,
+	type FieldComponent,
+	FieldWidthSchema,
+	type FieldWidth,
+
+	// Field metadata
+	FieldUISchema,
+	type FieldUI,
+	FieldOptionSchema,
+	type FieldOption,
+	ReferenceConfigSchema,
+	type ReferenceConfig,
+	FieldAccessSchema,
+	type FieldAccess,
+	ConfigFieldMetaSchema,
+	type ConfigFieldMeta,
+	ConfigFieldGroupSchema,
+	type ConfigFieldGroup,
+
+	// Navigation
+	ManifestNavigationSchema,
+	type ManifestNavigation,
+
+	// Context
+	ManifestContextSchema,
+	type ManifestContext
+} from './config-manifest-descriptor';
+
+// Config Collection
+export { ConfigCollectionDescriptorSchema, type ConfigCollectionDescriptor } from './collection';

package/src/server/index.ts

@@ -0,0 +1,4 @@
+export { ConfigCollectionDescriptorSchema } from '../schemas/index.ts';
+export type { ConfigCollectionDescriptor } from '../schemas/index.ts';
+import * as configLoaderSrc from '../loader/index.ts';
+export const configLoader = configLoaderSrc;

package/src/services/config-accessor.ts

@@ -0,0 +1,218 @@
+/**
+ * Config Accessor
+ *
+ * Provides a simple accessor interface for config values that works with
+ * the runtime and unified loader. Replaces the legacy registry accessor.
+ *
+ * @example
+ * ```ts
+ * const accessor = await createConfigAccessor(manifest);
+ *
+ * // Get current value
+ * const value = accessor.get();
+ *
+ * // Set a field
+ * accessor.setField('fieldName', newValue);
+ *
+ * // Save changes
+ * await accessor.save();
+ * ```
+ */
+
+import type { ConfigManifest, ConfigContext } from '../manifest/types.ts';
+import { loadConfigFromManifest } from '../loader/index.ts';
+import { getVibesRuntime } from '@vibesdotdev/runtime';
+import type { ConfigLoaderInterface } from './loader/loader.descriptor.ts';
+
+import type { ConfigAccessor } from './schemas/config-accessor.schema.ts';
+
+export type { ConfigAccessor } from './schemas/config-accessor.schema.ts';
+
+/**
+ * Internal state for a config accessor
+ */
+interface AccessorState<T> {
+	values: T | null;
+	dirty: boolean;
+	subscribers: Set<(values: T | null) => void>;
+}
+
+/**
+ * Create a config accessor for a manifest
+ *
+ * @param manifest - The config manifest
+ * @param context - Optional config context for initialization
+ * @returns A promise that resolves to the accessor
+ */
+export async function createConfigAccessor<T extends Record<string, unknown>>(
+	manifest: ConfigManifest<any>,
+	_context?: Partial<ConfigContext>
+): Promise<ConfigAccessor<T>> {
+	const state: AccessorState<T> = {
+		values: null,
+		dirty: false,
+		subscribers: new Set()
+	};
+
+	// Load initial values
+	const result = await loadConfigFromManifest<T>({
+		manifest,
+		includeStorage: true,
+		includeDefaults: true
+	});
+	state.values = result.data;
+
+	const notifySubscribers = () => {
+		for (const callback of state.subscribers) {
+			callback(state.values);
+		}
+	};
+
+	return {
+		get(): T | null {
+			return state.values;
+		},
+
+		setField<K extends keyof T>(field: K, value: T[K]): void {
+			if (state.values === null) {
+				state.values = { [field]: value } as T;
+			} else {
+				state.values = { ...state.values, [field]: value };
+			}
+			state.dirty = true;
+			notifySubscribers();
+		},
+
+		setFields(fields: Partial<T>): void {
+			if (state.values === null) {
+				state.values = fields as T;
+			} else {
+				state.values = { ...state.values, ...fields };
+			}
+			state.dirty = true;
+			notifySubscribers();
+		},
+
+		subscribe(callback: (values: T | null) => void): () => void {
+			state.subscribers.add(callback);
+			return () => {
+				state.subscribers.delete(callback);
+			};
+		},
+
+		async save(): Promise<void> {
+			if (!state.values || !state.dirty) return;
+
+			const loader = (await getVibesRuntime()
+				.query('config/loader')
+				.resolve()) as ConfigLoaderInterface | undefined;
+			if (!loader) throw new Error('No config/loader registered');
+			await loader.save(manifest, state.values);
+			state.dirty = false;
+		},
+
+		async reload(): Promise<void> {
+			const result = await loadConfigFromManifest<T>({
+				manifest,
+				includeStorage: true,
+				includeDefaults: true
+			});
+			state.values = result.data;
+			state.dirty = false;
+			notifySubscribers();
+		},
+
+		isDirty(): boolean {
+			return state.dirty;
+		}
+	};
+}
+
+/**
+ * Synchronous config accessor for cases where values are already loaded
+ * Useful for UI components that need immediate access
+ */
+export function createSyncConfigAccessor<T extends Record<string, unknown>>(
+	manifest: ConfigManifest<any>,
+	initialValues: T | null = null
+): ConfigAccessor<T> & { setValue: (values: T) => void } {
+	const state: AccessorState<T> = {
+		values: initialValues,
+		dirty: false,
+		subscribers: new Set()
+	};
+
+	const notifySubscribers = () => {
+		for (const callback of state.subscribers) {
+			callback(state.values);
+		}
+	};
+
+	return {
+		get(): T | null {
+			return state.values;
+		},
+
+		setValue(values: T): void {
+			state.values = values;
+			notifySubscribers();
+		},
+
+		setField<K extends keyof T>(field: K, value: T[K]): void {
+			if (state.values === null) {
+				state.values = { [field]: value } as T;
+			} else {
+				state.values = { ...state.values, [field]: value };
+			}
+			state.dirty = true;
+			notifySubscribers();
+		},
+
+		setFields(fields: Partial<T>): void {
+			if (state.values === null) {
+				state.values = fields as T;
+			} else {
+				state.values = { ...state.values, ...fields };
+			}
+			state.dirty = true;
+			notifySubscribers();
+		},
+
+		subscribe(callback: (values: T | null) => void): () => void {
+			state.subscribers.add(callback);
+			callback(state.values);
+			return () => {
+				state.subscribers.delete(callback);
+			};
+		},
+
+		async save(): Promise<void> {
+			if (!state.values || !state.dirty) return;
+
+			const loader = (await getVibesRuntime()
+				.query('config/loader')
+				.resolve()) as ConfigLoaderInterface | undefined;
+			if (!loader) throw new Error('No config/loader registered');
+			await loader.save(manifest, state.values);
+			state.dirty = false;
+		},
+
+		async reload(): Promise<void> {
+			const result = await loadConfigFromManifest<T>({
+				manifest,
+				includeStorage: true,
+				includeDefaults: true
+			});
+			state.values = result.data;
+			state.dirty = false;
+			notifySubscribers();
+		},
+
+		isDirty(): boolean {
+			return state.dirty;
+		}
+	};
+}
+
+// Re-export the ConfigAccessor type for convenience
+export type { ConfigAccessor as ConfigAccessorInterface };

package/src/services/config-storage/index.ts

@@ -0,0 +1,8 @@
+/**
+ * Config Storage Service
+ *
+ * Runtime-resolved storage adapter for configuration storage.
+ */
+
+export { ConfigStorageService, getConfigStorageService, resetConfigStorageService } from './service.ts';
+export type { CredentialsInput, ConfigDocumentInput, ConfigScope } from './service.ts';