@vibesdotdev/config 0.0.1

package/src/form/index.ts

@@ -0,0 +1,36 @@
+/**
+ * Config Form Module
+ *
+ * Core form rendering infrastructure for manifest-driven forms
+ */
+export type {
+	RenderContext,
+	ComponentOverride,
+	FormRenderOptions,
+	ResolvedField,
+	ResolvedGroup,
+	FormState,
+	FormActions
+} from './core/index.ts';
+export {
+	inferFieldComponent,
+	getFieldDefault,
+	resolveFields,
+	groupFields,
+	resolveFieldDefault,
+	resolveDefaults,
+	validateField,
+	validateForm,
+	getFieldSchema,
+	evaluateRule,
+	isFieldVisible,
+	isFieldDisabled,
+	isFieldRequired,
+	resolveGroups,
+	getGroupFields,
+	isGroupCollapsed,
+	getNestedValue,
+	setNestedValue,
+	buildNestedObject,
+	flattenNestedObject
+} from './core/index.ts';

package/src/index.ts

@@ -0,0 +1,69 @@
+/**
+ * Universal Configuration Module
+ *
+ * Schema-driven configuration system for all surfaces:
+ * - TUI (Studio)
+ * - CLI
+ * - Web (SvelteKit)
+ * - Bridge App
+ */
+
+// Schemas (New Runtime API)
+
+export {
+	ConfigManifestDescriptorSchema,
+	isConfigManifestDescriptor,
+	ConfigTierSchema,
+	ConfigSurfaceSchema,
+	HardwareContextSchema,
+	EnvironmentContextSchema,
+	FieldComponentSchema,
+	FieldWidthSchema,
+	FieldUISchema,
+	FieldOptionSchema,
+	ReferenceConfigSchema,
+	FieldAccessSchema,
+	ConfigFieldMetaSchema,
+	ConfigFieldGroupSchema,
+	ManifestNavigationSchema,
+	ManifestContextSchema,
+	ConfigCollectionDescriptorSchema
+} from './schemas/index.ts';
+export type {
+	ConfigManifestDescriptor,
+	ConfigTier,
+	ConfigSurface,
+	HardwareContext,
+	EnvironmentContext,
+	FieldComponent,
+	FieldWidth,
+	FieldUI,
+	FieldOption,
+	ReferenceConfig,
+	FieldAccess,
+	ConfigFieldMeta,
+	ConfigFieldGroup,
+	ManifestNavigation,
+	ManifestContext,
+	ConfigCollectionDescriptor
+} from './schemas/index.ts';
+
+// Manifest Class
+
+export { ConfigManifest } from './manifest/config-manifest.ts';
+export type { ConfigChangeCallback } from './manifest/config-manifest.ts';
+
+// Config Collection
+
+export { ConfigCollection } from './collection/collection.ts';
+export type { CollectionState, CollectionCallback } from './collection/collection.ts';
+
+// Config Doctor
+
+export { diagnoseConfig, diagnoseCollection } from './doctor.ts';
+export type {
+	DiagnosticSeverity,
+	DiagnosticIssue,
+	DetailedDiagnostic,
+	DiagnoseConfigOptions
+} from './doctor.ts';

package/src/js-yaml.d.ts

@@ -0,0 +1,4 @@
+declare module 'js-yaml' {
+	export function load<T = unknown>(input: string): T;
+	export function dump(value: unknown, options?: { noRefs?: boolean }): string;
+}

package/src/loader/cli/index.ts

@@ -0,0 +1,386 @@
+/**
+ * Unified Config Loader for CLI
+ *
+ * Provides a single, consistent way to load configs with proper
+ * specificity ordering and format support.
+ *
+ * This is the CLI-specific loader that uses ConfigStorageService from
+ * the config package's storage layer instead of LocalDB directly.
+ */
+
+import type {
+	ConfigLoaderOptions,
+	ConfigLoadResult,
+	ConfigSource,
+	ConfigScope,
+	ConfigSaveOptions
+} from './types';
+import {
+	getConfigSearchPaths,
+	getDefaultScopes,
+	getNestedValue,
+	setNestedValue,
+	deepMerge,
+	detectSecrets,
+	detectFormat,
+	fileExists,
+	ensureDir,
+	getVibesDir
+} from './utils';
+
+async function getLoaders() {
+	// `./loaders` is a literal subpath — let vite resolve and chunk it.
+	// The previous `/* @vite-ignore */` left an unresolved relative import
+	// in the chunked output that wrangler's esbuild pass could not
+	// resolve (the parent chunk landed in `output/server/chunks/` while
+	// the relative target lived elsewhere).
+	return import('./loaders');
+}
+
+import { dirname } from 'path';
+
+// Storage service will be imported from config-storage service
+// For now, placeholder that will be resolved when the service is created
+let _configStorageService: any = null;
+
+function getStorageService() {
+	if (!_configStorageService) {
+		// Will use runtime.resolve('config-storage/service') when available
+		throw new Error('ConfigStorageService not initialized. Call setStorageService() first.');
+	}
+	return _configStorageService;
+}
+
+export function setStorageService(service: any) {
+	_configStorageService = service;
+}
+
+/**
+ * Load configuration with proper specificity ordering
+ *
+ * Specificity order (least → most specific):
+ * 1. Global: stored in config storage under scope='global'
+ * 2. Local: stored in config storage under scope='local'
+ * 3. Project: stored in config storage under scope='project'
+ *
+ * Later configs override earlier ones via deep merge.
+ *
+ * If configPath is provided, loads from that file directly (for imports).
+ */
+export async function loadConfig<T = any>(
+	options: ConfigLoaderOptions<T> = {}
+): Promise<ConfigLoadResult<T>> {
+	const {
+		configPath,
+		scopes = getDefaultScopes(),
+		schema,
+		merge = true,
+		namespace,
+		warnSecrets = false
+	} = options;
+
+	if (configPath) {
+		return loadConfigFromFile<T>(configPath, options);
+	}
+
+	return loadConfigFromStorage<T>({
+		...options,
+		scopes,
+		namespace,
+		warnSecrets
+	});
+}
+
+/**
+ * Load configuration from a specific file path (import mode)
+ */
+async function loadConfigFromFile<T = any>(
+	configPath: string,
+	options: ConfigLoaderOptions<T>
+): Promise<ConfigLoadResult<T>> {
+	const { schema, namespace, warnSecrets = true } = options;
+
+	const { loadConfigFromPath } = await getLoaders();
+	const config = await loadConfigFromPath(configPath, options.format);
+	const format = detectFormat(configPath);
+	const extractedConfig = namespace ? getNestedValue(config, namespace) || {} : config;
+
+	const sources: ConfigSource[] = [
+		{
+			path: configPath,
+			scope: 'project',
+			format,
+			exists: true,
+		merged: false
+		}
+	];
+
+	const allSecrets: any[] = [];
+	if (warnSecrets && (format === 'ts' || format === 'js')) {
+		const secrets = detectSecrets(extractedConfig, configPath);
+		allSecrets.push(...secrets);
+	}
+
+	const finalConfig = schema ? schema.parse(extractedConfig) : extractedConfig;
+
+	return {
+		config: finalConfig,
+		sources,
+		secrets: allSecrets.length > 0 ? allSecrets : undefined
+	};
+}
+
+/**
+ * Load configuration from storage service
+ */
+async function loadConfigFromStorage<T = any>(
+	options: ConfigLoaderOptions<T>
+): Promise<ConfigLoadResult<T>> {
+	const { scopes, schema, merge = true, namespace, warnSecrets = false } = options;
+	const service = getStorageService();
+	const allSecrets: any[] = [];
+	const sources: ConfigSource[] = [];
+
+	const nsValue = namespace ?? null;
+
+	const { config: mergedConfig, sources: storageSources } = await service.getDocumentMerged(
+		scopes ?? ['global', 'local', 'project'],
+		null
+	);
+
+	for (const storageSource of storageSources) {
+		sources.push({
+			path: `storage:${storageSource.scope}${nsValue ? `:${nsValue}` : ''}`,
+			scope: storageSource.scope,
+			format: 'json',
+			exists: true,
+			merged: merge
+		});
+	}
+
+	for (const scope of scopes ?? ['global', 'local', 'project']) {
+		if (!storageSources.find((s: any) => s.scope === scope)) {
+			sources.push({
+				path: `storage:${scope}${nsValue ? `:${nsValue}` : ''}`,
+				scope,
+				format: 'json',
+				exists: false,
+				merged: false
+			});
+		}
+	}
+
+	let extractedConfig = mergedConfig;
+	if (nsValue && mergedConfig) {
+		extractedConfig = getNestedValue(mergedConfig, nsValue) || {};
+	}
+
+	if (warnSecrets && extractedConfig) {
+		const secrets = detectSecrets(extractedConfig, 'storage', '');
+		allSecrets.push(...secrets);
+	}
+
+	const finalConfig = schema ? schema.parse(extractedConfig) : extractedConfig;
+
+	return {
+		config: finalConfig ?? ({} as T),
+		sources,
+		secrets: allSecrets.length > 0 ? allSecrets : undefined
+	};
+}
+
+/**
+ * Save configuration to storage
+ */
+export async function saveConfig<T = any>(config: T, options: ConfigSaveOptions): Promise<void> {
+	const { scope, namespace, merge: shouldMerge = true, encrypt = false } = options;
+	const service = getStorageService();
+	const nsValue = namespace ?? null;
+
+	let contentToSave: Record<string, unknown>;
+
+	if (nsValue) {
+		const existing = await service.getDocument(scope, null);
+		contentToSave = existing || {};
+		setNestedValue(contentToSave, nsValue, config);
+	} else {
+		contentToSave = config as Record<string, unknown>;
+	}
+
+	if (shouldMerge) {
+		await service.mergeDocument(scope, contentToSave, null);
+	} else {
+		await service.setDocument({
+			scope,
+			namespace: null,
+			content: contentToSave,
+			encrypted: encrypt
+		});
+	}
+}
+
+/**
+ * Check if any config exists for given options
+*/
+export async function configExists(
+	scopes: ConfigScope[] = getDefaultScopes(),
+	namespace?: string
+): Promise<boolean> {
+	const nsValue = namespace ?? null;
+	const service = getStorageService();
+
+	for (const scope of scopes) {
+		const doc = await service.getDocument(scope, nsValue);
+		if (doc && Object.keys(doc).length > 0) {
+			return true;
+		}
+	}
+
+	return false;
+}
+
+/**
+ * Get all existing config sources
+ */
+export async function getExistingConfigs(
+	scopes: ConfigScope[] = getDefaultScopes(),
+	namespace?: string
+): Promise<ConfigSource[]> {
+	const nsValue = namespace ?? null;
+	const service = getStorageService();
+	const sources: ConfigSource[] = [];
+
+	for (const scope of scopes) {
+		const doc = await service.getDocument(scope, nsValue);
+		sources.push({
+			path: `storage:${scope}${nsValue ? `:${nsValue}` : ''}`,
+			scope,
+			format: 'json',
+			exists: doc !== null && Object.keys(doc).length > 0,
+			merged: false
+		});
+	}
+
+	return sources;
+}
+
+/**
+ * Import configuration from a file into storage
+ */
+export async function importConfigFromFile(
+	filePath: string,
+	targetScope: ConfigScope,
+	options: {
+		namespace?: string;
+		merge?: boolean;
+		format?: 'ts' | 'js' | 'json' | 'yaml' | 'auto';
+	} = {}
+): Promise<{ imported: boolean; keys: number }> {
+	const { namespace, merge = true, format } = options;
+
+	const { loadConfigFromPath } = await getLoaders();
+	const config = await loadConfigFromPath(filePath, format);
+
+	if (!config || Object.keys(config).length === 0) {
+		return { imported: false, keys: 0 };
+	}
+
+	const nsValue = namespace ?? null;
+	const service = getStorageService();
+
+	let contentToSave: Record<string, unknown>;
+	if (nsValue) {
+		const existing = await service.getDocument(targetScope, null);
+		contentToSave = existing || {};
+		setNestedValue(contentToSave, nsValue, config);
+	} else {
+		contentToSave = config;
+	}
+
+	if (merge) {
+		await service.mergeDocument(targetScope, contentToSave, null);
+	} else {
+		await service.setDocument({
+			scope: targetScope,
+			namespace: null,
+			content: contentToSave,
+			encrypted: false
+		});
+	}
+
+	const countKeys = (obj: any): number => {
+		let count = 0;
+		for (const value of Object.values(obj)) {
+			count++;
+			if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+				count += countKeys(value);
+			}
+		}
+		return count;
+	};
+
+	return { imported: true, keys: countKeys(config) };
+}
+
+/**
+ * Export configuration from storage to a file
+ */
+export async function exportConfigToFile(
+	filePath: string,
+	scope: ConfigScope,
+	options: {
+		namespace?: string;
+		format?: 'json' | 'yaml';
+		pretty?: boolean;
+	} = {}
+): Promise<{ exported: boolean; keys: number }> {
+	const { namespace, format = 'json', pretty = true } = options;
+
+	const service = getStorageService();
+	const doc = await service.getDocument(scope, namespace ?? null);
+
+	if (!doc || Object.keys(doc).length === 0) {
+		return { exported: false, keys: 0 };
+	}
+
+	await ensureDir(dirname(filePath));
+
+	const { saveConfigToPath } = await getLoaders();
+	await saveConfigToPath(doc, filePath, format, pretty);
+
+	const countKeys = (obj: any): number => {
+		let count = 0;
+		for (const value of Object.values(obj)) {
+			count++;
+			if (typeof value === 'object' && value !== null && !Array.isArray(value)) {
+				count += countKeys(value);
+			}
+		}
+		return count;
+	};
+
+	return { exported: true, keys: countKeys(doc) };
+}
+
+// Re-export types and utilities
+export type {
+	ConfigFormat,
+	ConfigScope,
+	ConfigLoaderOptions,
+	ConfigLoadResult,
+	ConfigSource,
+	SecretDetection,
+	ConfigSaveOptions
+} from './types';
+export {
+	getVibesDir,
+	getConfigPath,
+	getConfigSearchPaths,
+	getDefaultScopes,
+	detectFormat,
+	deepMerge,
+	isSensitiveKey,
+	detectSecrets,
+	fileExists,
+	ensureDir
+} from './utils';

package/src/loader/cli/loaders.ts

@@ -0,0 +1,153 @@
+/**
+ * Unified Config Loader - Format-specific loaders
+ */
+
+import type { ConfigFormat } from './types';
+import { detectFormat, fileExists } from './utils';
+
+/**
+ * Load config from a file path with format detection
+ */
+export async function loadConfigFromPath(path: string, format?: ConfigFormat): Promise<any> {
+	if (!(await fileExists(path))) {
+		throw new Error(`Config file not found: ${path}`);
+	}
+
+	const fileFormat = format && format !== 'auto' ? format : detectFormat(path);
+
+	switch (fileFormat) {
+		case 'ts':
+			return await loadTypeScriptConfig(path);
+		case 'js':
+			return await loadJavaScriptConfig(path);
+		case 'json':
+			return await loadJSONConfig(path);
+		case 'yaml':
+			return await loadYAMLConfig(path);
+		default:
+			throw new Error(`Unsupported config format: ${fileFormat}`);
+	}
+}
+
+/**
+ * Load TypeScript config file
+ */
+async function loadTypeScriptConfig(path: string): Promise<any> {
+	try {
+		const module = await import(/* @vite-ignore */ path);
+		const config = module.default || module.config || module;
+
+		if (typeof config === 'function') {
+			return await config();
+		}
+
+		return config;
+	} catch (error) {
+		throw new Error(
+			`Failed to load TypeScript config from ${path}: ${error instanceof Error ? error.message : String(error)}`
+		);
+	}
+}
+
+/**
+ * Load JavaScript config file
+ */
+async function loadJavaScriptConfig(path: string): Promise<any> {
+	try {
+		const module = await import(/* @vite-ignore */ path);
+		const config = module.default || module.config || module;
+
+		if (typeof config === 'function') {
+			return await config();
+		}
+
+		return config;
+	} catch (error) {
+		throw new Error(
+			`Failed to load JavaScript config from ${path}: ${error instanceof Error ? error.message : String(error)}`
+		);
+	}
+}
+
+/**
+ * Load JSON config file
+ */
+async function loadJSONConfig(path: string): Promise<any> {
+	try {
+		const file = Bun.file(path);
+		const content = await file.text();
+		return JSON.parse(content);
+	} catch (error) {
+		throw new Error(
+			`Failed to load JSON config from ${path}: ${error instanceof Error ? error.message : String(error)}`
+		);
+	}
+}
+
+/**
+ * Load YAML config file
+ */
+async function loadYAMLConfig(path: string): Promise<any> {
+	try {
+		const file = Bun.file(path);
+		const content = await file.text();
+		const { parse } = await import('yaml');
+		return parse(content);
+	} catch (error) {
+		throw new Error(
+			`Failed to load YAML config from ${path}: ${error instanceof Error ? error.message : String(error)}`
+		);
+	}
+}
+
+/**
+ * Save config to a file path
+ */
+export async function saveConfigToPath(
+	config: any,
+	path: string,
+	format?: ConfigFormat,
+	pretty = true
+): Promise<void> {
+	const fileFormat = format && format !== 'auto' ? format : detectFormat(path);
+
+	let content: string;
+
+	switch (fileFormat) {
+		case 'ts':
+		case 'js':
+			content = generateModuleConfig(config, fileFormat);
+			break;
+		case 'json':
+			content = JSON.stringify(config, null, pretty ? 2 : 0);
+			break;
+		case 'yaml':
+			const { stringify } = await import('yaml');
+			content = stringify(config, null, pretty ? 2 : 0);
+			break;
+		default:
+			throw new Error(`Unsupported config format for saving: ${fileFormat}`);
+	}
+
+	await Bun.write(path, content);
+
+	if (fileFormat === 'json') {
+		await Bun.spawn(['chmod', '600', path], { stderr: 'ignore' }).exited;
+	}
+}
+
+/**
+ * Generate TS/JS module config content
+ */
+function generateModuleConfig(config: any, format: 'ts' | 'js'): string {
+	const isTS = format === 'ts';
+	const typeAnnotation = isTS ? ': any' : '';
+
+	const configStr = JSON.stringify(config, null, 2)
+		.replace(/"([^"]+)":/g, '$1:')
+		.replace(/"/g, "'");
+
+	return `${isTS ? '// TypeScript Config\n' : '// JavaScript Config\n'}
+export default ${typeAnnotation} ${configStr};
+`;
+}