@vibesdotdev/config 0.0.1

package/src/manifest/schema.ts

@@ -0,0 +1,249 @@
+/**
+ * Configuration Manifest Schemas
+ *
+ * Zod schemas for validating manifest structures.
+ * These are "meta-schemas" - schemas that validate configuration schemas.
+ */
+
+import * as z from 'zod/v4';
+
+// Enums and Literals
+
+export const configTierSchema = z.enum(['system', 'user', 'internal']);
+
+export const storageAdapterSchema = z.enum([
+	'auto',
+	'json',
+	'localdb',
+	'cloud',
+	'database',
+	'env',
+	'encrypted',
+	'memory'
+]);
+
+export const storageScopeSchema = z.enum(['global', 'project', 'auto']);
+
+export const configSurfaceSchema = z.enum(['tui', 'cli', 'web', 'bridge']);
+
+export const hardwareContextSchema = z.enum(['cloud', 'consumer', 'gpu', 'cpu-only']);
+
+export const environmentContextSchema = z.enum(['development', 'staging', 'production']);
+
+export const fieldComponentSchema = z.enum([
+	'input',
+	'textarea',
+	'number',
+	'select',
+	'multi-select',
+	'radio-group',
+	'checkbox',
+	'switch',
+	'slider',
+	'color',
+	'date',
+	'datetime',
+	'file',
+	'password',
+	'secret',
+	'json',
+	'code',
+	'custom'
+]);
+
+export const fieldWidthSchema = z.enum(['full', 'half', 'third', 'quarter']);
+
+export const ruleOperatorSchema = z.enum([
+	'equals',
+	'notEquals',
+	'in',
+	'notIn',
+	'exists',
+	'isEmpty'
+]);
+
+// Config Rules (Recursive)
+
+// Base rule types (non-recursive)
+const fieldRuleSchema = z.object({
+	field: z.string(),
+	operator: ruleOperatorSchema,
+	value: z.unknown().optional()
+});
+
+const contextRuleSchema = z.object({
+	context: z.string(), // keyof ConfigContext or custom.*
+	operator: ruleOperatorSchema.exclude(['isEmpty']),
+	value: z.unknown().optional()
+});
+
+// For JSON serialization, we use a simplified rule schema
+// Function rules can't be serialized, so they're handled separately
+export const configRuleSchema: z.ZodType<unknown> = z.lazy(() =>
+	z.union([
+		fieldRuleSchema,
+		contextRuleSchema,
+		z.object({ and: z.array(configRuleSchema) }),
+		z.object({ or: z.array(configRuleSchema) }),
+		z.object({ not: configRuleSchema })
+	])
+);
+
+// Field UI Schema
+
+export const fieldUISchema = z.object({
+	label: z.string().min(1),
+	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().int().optional(),
+	group: z.string().optional(),
+	width: fieldWidthSchema.optional(),
+	hideLabel: z.boolean().optional(),
+	className: z.string().optional()
+});
+
+// Field Option Schema
+
+export const fieldOptionSchema = z.object({
+	value: z.union([z.string(), z.number(), z.boolean()]),
+	label: z.string().min(1),
+	description: z.string().optional(),
+	icon: z.string().optional(),
+	disabledWhen: configRuleSchema.optional(),
+	hiddenWhen: configRuleSchema.optional()
+});
+
+// Field Access Schema
+
+export const fieldAccessSchema = z.object({
+	isPublic: z.boolean().optional(),
+	isEditable: z.boolean().optional(),
+	requiredRole: z.string().optional(),
+	surfaces: z.array(configSurfaceSchema).optional()
+});
+
+// Field Rules Schema
+
+export const fieldRulesSchema = z.object({
+	visibleWhen: configRuleSchema.optional(),
+	disabledWhen: configRuleSchema.optional(),
+	requiredWhen: configRuleSchema.optional(),
+	warnWhen: configRuleSchema.optional(),
+	warnMessage: z.string().optional()
+});
+
+// Field Defaults Schema
+
+export const fieldDefaultsSchema = z.object({
+	base: z.unknown(),
+	byHardware: z.record(hardwareContextSchema, z.unknown()).optional(),
+	byEnvironment: z.record(environmentContextSchema, z.unknown()).optional(),
+	bySurface: z.record(configSurfaceSchema, z.unknown()).optional()
+	// resolver is a function, can't be serialized
+});
+
+// Field Metadata Schema
+
+export const configFieldMetaSchema = z.object({
+	ui: fieldUISchema,
+	rules: fieldRulesSchema.optional(),
+	defaults: fieldDefaultsSchema.optional(),
+	options: z.array(fieldOptionSchema).optional(),
+	access: fieldAccessSchema.optional(),
+	dependsOn: z.array(z.string()).optional(),
+	tags: z.array(z.string()).optional()
+});
+
+// Field Group Schema
+
+export const configFieldGroupSchema = z.object({
+	id: z.string().min(1),
+	label: z.string().min(1),
+	description: z.string().optional(),
+	icon: z.string().optional(),
+	order: z.number().int().optional(),
+	collapsible: z.boolean().optional(),
+	defaultCollapsed: z.boolean().optional(),
+	visibleWhen: configRuleSchema.optional()
+});
+
+// Storage Schema
+
+export const manifestStorageSchema = z.object({
+	adapter: storageAdapterSchema,
+	scope: storageScopeSchema.optional(),
+	namespace: z.string().min(1),
+	encryptSensitive: z.boolean().optional(),
+	sensitiveFields: z.array(z.string()).optional(),
+	version: z.number().int().positive().optional()
+});
+
+// Context Constraints Schema
+
+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()
+});
+
+// Manifest Schema (for serialization/validation)
+
+/**
+ * Schema for validating manifest structure (excluding runtime-only fields)
+ * This is used for serialization and documentation generation
+ */
+export const configManifestMetaSchema = z.object({
+	// Identity
+	id: z
+		.string()
+		.min(1)
+		.regex(/^[a-z][a-z0-9._-]*$/, 'ID must be lowercase with dots, dashes, or underscores'),
+	name: z.string().min(1),
+	description: z.string().optional(),
+	icon: z.string().optional(),
+	version: z.number().int().positive().optional(),
+
+	// Classification
+	tier: configTierSchema,
+	category: z.string().optional(),
+
+	// Schema is validated at runtime, not here
+	// schema: z.any() - excluded
+
+	// Field Metadata
+	fields: z.record(z.string(), configFieldMetaSchema),
+	groups: z.array(configFieldGroupSchema).optional(),
+
+	// Storage
+	storage: manifestStorageSchema,
+
+	// Context
+	context: manifestContextSchema.optional()
+
+	// Lifecycle hooks are functions, can't be serialized
+});
+
+export type {
+	ConfigTier,
+	StorageAdapter,
+	StorageScope,
+	ConfigSurface,
+	HardwareContext,
+	EnvironmentContext,
+	FieldComponent,
+	FieldWidth,
+	FieldUI,
+	FieldOption,
+	FieldAccess,
+	FieldRules,
+	FieldDefaults,
+	ConfigFieldMeta,
+	ConfigFieldGroup,
+	ManifestStorage,
+	ManifestContext
+} from './schemas/schema.schema.ts';

package/src/manifest/schemas/builder.schema.ts

@@ -0,0 +1,33 @@
+import type { z } from 'zod/v4';
+import type {
+	ConfigFieldMeta,
+	ConfigFieldGroup,
+	ConfigTier,
+	ManifestStorage,
+	ManifestContext,
+	FieldUI,
+	FieldOption,
+	FieldDefaults,
+	FieldRules,
+	HardwareContext,
+	EnvironmentContext,
+	ConfigSurface
+} from './schema.schema.ts';
+import type { ConfigManifest, ManifestNavigation, ConfigContext } from '../types.ts';
+
+export interface CreateManifestOptions<T extends z.ZodTypeAny> {
+	id: string;
+	name: string;
+	description?: string;
+	icon?: string;
+	version?: number;
+	tier: ConfigTier;
+	category?: string;
+	schema: T;
+	storage: ManifestStorage;
+	context?: ManifestContext;
+	navigation?: ManifestNavigation;
+	onLoad?: ConfigManifest<T>['onLoad'];
+	onSave?: ConfigManifest<T>['onSave'];
+	onFieldChange?: ConfigManifest<T>['onFieldChange'];
+}

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

@@ -0,0 +1 @@
+export type ConfigChangeCallback<T> = (config: T | null) => void;

package/src/manifest/schemas/schema.schema.ts

@@ -0,0 +1,99 @@
+export type ConfigTier = 'system' | 'user' | 'internal';
+export type StorageAdapter =
+	| 'auto'
+	| 'json'
+	| 'localdb'
+	| 'cloud'
+	| 'database'
+	| 'env'
+	| 'encrypted'
+	| 'memory';
+export type StorageScope = 'global' | 'project' | 'auto';
+export type ConfigSurface = 'tui' | 'cli' | 'web' | 'bridge';
+export type HardwareContext = 'cloud' | 'consumer' | 'gpu' | 'cpu-only';
+export type EnvironmentContext = 'development' | 'staging' | 'production';
+export type FieldComponent = 'input' | 'textarea' | 'number' | 'select' | 'multi-select' | 'radio-group' | 'checkbox' | 'switch' | 'slider' | 'color' | 'date' | 'datetime' | 'file' | 'password' | 'secret' | 'json' | 'code' | 'custom';
+export type FieldWidth = 'full' | 'half' | 'third' | 'quarter';
+
+export interface FieldUI {
+	label: string;
+	description?: string;
+	helpText?: string;
+	placeholder?: string;
+	icon?: string;
+	component?: FieldComponent;
+	customComponent?: string;
+	order?: number;
+	group?: string;
+	width?: FieldWidth;
+	hideLabel?: boolean;
+	className?: string;
+}
+
+export interface FieldOption<T extends string = string> {
+	value: T;
+	label: string;
+	description?: string;
+	icon?: string;
+	disabledWhen?: unknown;
+	hiddenWhen?: unknown;
+}
+
+export interface FieldAccess {
+	isPublic?: boolean;
+	isEditable?: boolean;
+	requiredRole?: string;
+	surfaces?: ConfigSurface[];
+}
+
+export interface FieldRules {
+	visibleWhen?: unknown;
+	disabledWhen?: unknown;
+	requiredWhen?: unknown;
+	warnWhen?: unknown;
+	warnMessage?: string;
+}
+
+export interface FieldDefaults<T = unknown> {
+	base: T;
+	byHardware?: Partial<Record<HardwareContext, T>>;
+	byEnvironment?: Partial<Record<EnvironmentContext, T>>;
+	bySurface?: Partial<Record<ConfigSurface, T>>;
+}
+
+export interface ConfigFieldMeta {
+	ui: FieldUI;
+	rules?: FieldRules;
+	defaults?: FieldDefaults;
+	options?: FieldOption[];
+	access?: FieldAccess;
+	dependsOn?: string[];
+	tags?: string[];
+}
+
+export interface ConfigFieldGroup {
+	id: string;
+	label: string;
+	description?: string;
+	icon?: string;
+	order?: number;
+	collapsible?: boolean;
+	defaultCollapsed?: boolean;
+	visibleWhen?: unknown;
+}
+
+export interface ManifestStorage {
+	adapter: StorageAdapter;
+	scope?: StorageScope;
+	namespace: string;
+	encryptSensitive?: boolean;
+	sensitiveFields?: string[];
+	version?: number;
+}
+
+export interface ManifestContext {
+	hardware?: HardwareContext[];
+	environment?: EnvironmentContext[];
+	surfaces?: ConfigSurface[];
+	requiredFeatures?: string[];
+}