@vibesdotdev/config 0.0.1

package/src/loader/cli/types.ts

@@ -0,0 +1,181 @@
+/**
+ * Unified Config Loader - Type Definitions
+ */
+
+import type { ZodSchema } from 'zod/v4';
+
+/**
+ * Config file format
+ */
+export type ConfigFormat = 'ts' | 'js' | 'json' | 'yaml' | 'auto';
+
+/**
+ * Config scope with specificity order
+ */
+export type ConfigScope = 'global' | 'local' | 'project';
+
+/**
+ * Config loader options
+ */
+export interface ConfigLoaderOptions<T = any> {
+	/**
+	 * Explicit config path (highest priority, no merging)
+	 */
+	configPath?: string;
+
+	/**
+	 * Custom search paths (in order of specificity: least → most)
+	 */
+	searchPaths?: string[];
+
+	/**
+	 * Config format (auto-detect if not specified)
+	 */
+	format?: ConfigFormat;
+
+	/**
+	 * Scopes to load and merge (in order: global → local → project)
+	 */
+	scopes?: ConfigScope[];
+
+	/**
+	 * Zod schema for validation
+	 */
+	schema?: ZodSchema<T>;
+
+	/**
+	 * Whether to merge all found configs (default: true)
+	 * If false, returns first found config
+	 */
+	merge?: boolean;
+
+	/**
+	 * Namespace/key to extract from loaded config
+	 * e.g., 'ai' to get config.ai
+	 */
+	namespace?: string;
+
+	/**
+	 * Whether to warn about secrets in TS files (default: true)
+	 */
+	warnSecrets?: boolean;
+
+	/**
+	 * Whether to auto-encrypt sensitive values (default: false)
+	 */
+	autoEncrypt?: boolean;
+}
+
+/**
+ * Config load result
+ */
+export interface ConfigLoadResult<T = any> {
+	/**
+	 * Merged/loaded config data
+	 */
+	config: T;
+
+	/**
+	 * Sources that were loaded (in order of specificity)
+	 */
+	sources: ConfigSource[];
+
+	/**
+	 * Detected secrets (if warnSecrets enabled)
+	 */
+	secrets?: SecretDetection[];
+}
+
+/**
+ * Config source info
+ */
+export interface ConfigSource {
+	/**
+	 * File path that was loaded
+	 */
+	path: string;
+
+	/**
+	 * Config scope
+	 */
+	scope: ConfigScope;
+
+	/**
+	 * Format that was loaded
+	 */
+	format: ConfigFormat;
+
+	/**
+	 * Whether this source exists
+	 */
+	exists: boolean;
+
+	/**
+	 * Whether this source was merged
+	 */
+	merged: boolean;
+}
+
+/**
+ * Secret detection result
+ */
+export interface SecretDetection {
+	/**
+	 * Key path of detected secret (e.g., 'service.<provider>.apiKey').
+	 *
+	 * Detection itself is domain-agnostic; specific manifest paths come from
+	 * the owning module's secret-detection rules.
+	 */
+	key: string;
+
+	/**
+	 * Value of secret (for migration)
+	 */
+	value: string;
+
+	/**
+	 * Source file where secret was found
+	 */
+	source: string;
+
+	/**
+	 * Pattern that matched (e.g., 'apiKey', 'secret', 'token')
+	 */
+	pattern: string;
+}
+
+/**
+ * Config save options
+ */
+export interface ConfigSaveOptions {
+	/**
+	 * Target scope
+	 */
+	scope: ConfigScope;
+
+	/**
+	 * Format to save as (default: json)
+	 */
+	format?: ConfigFormat;
+
+	/**
+	 * Whether to pretty-print (default: true)
+	 */
+	pretty?: boolean;
+
+	/**
+	 * Whether to encrypt sensitive values (default: true for JSON, false for TS/JS)
+	 */
+	encrypt?: boolean;
+
+	/**
+	 * Namespace/key to save under
+	 * e.g., 'ai' to save as config.ai
+	 */
+	namespace?: string;
+
+	/**
+	 * Whether to merge with existing config (default: true)
+	 */
+	merge?: boolean;
+}

package/src/loader/cli/utils.ts

@@ -0,0 +1,236 @@
+/**
+ * Unified Config Loader - Utilities
+ */
+
+import { join } from 'path';
+import { homedir } from 'os';
+import type { ConfigFormat, ConfigScope, SecretDetection } from './types';
+
+/**
+ * Get the vibes directory path
+ */
+export function getVibesDir(): string {
+	return join(homedir(), '.vibes');
+}
+
+/**
+ * Get config file path for a given scope and format
+ */
+export function getConfigPath(
+	scope: ConfigScope,
+	format: ConfigFormat = 'json',
+	namespace?: string
+): string {
+	const baseName = namespace ? `vibes.${namespace}` : 'vibes.config';
+	const ext = format === 'auto' ? 'json' : format;
+
+	switch (scope) {
+		case 'global':
+			return join(getVibesDir(), namespace ? `${namespace}.json` : 'config.json');
+		case 'local':
+			return join(process.cwd(), '.vibes', namespace ? `${namespace}.json` : 'config.json');
+		case 'project':
+			return join(process.cwd(), `${baseName}.${ext}`);
+	}
+}
+
+/**
+ * Get all possible config paths for a scope in order of priority (format precedence)
+ */
+export function getConfigSearchPaths(scope: ConfigScope, namespace?: string): string[] {
+	if (scope === 'global') {
+		return [getConfigPath('global', 'json', namespace)];
+	}
+
+	if (scope === 'local') {
+		const baseName = namespace ? namespace : 'config';
+		const baseDir = join(process.cwd(), '.vibes');
+		return [
+			join(baseDir, `${baseName}.ts`),
+			join(baseDir, `${baseName}.js`),
+			join(baseDir, `${baseName}.json`),
+			join(baseDir, `${baseName}.yaml`)
+		];
+	}
+
+	const baseName = namespace ? `vibes.${namespace}` : 'vibes.config';
+	return [
+		join(process.cwd(), `${baseName}.ts`),
+		join(process.cwd(), `${baseName}.js`),
+		join(process.cwd(), `${baseName}.json`),
+		join(process.cwd(), `${baseName}.yaml`)
+	];
+}
+
+/**
+ * Get default scopes in order of specificity (least → most)
+ */
+export function getDefaultScopes(): ConfigScope[] {
+	return ['global', 'local', 'project'];
+}
+
+/**
+ * Detect config format from file path
+ */
+export function detectFormat(path: string): ConfigFormat {
+	if (path.endsWith('.ts')) return 'ts';
+	if (path.endsWith('.js')) return 'js';
+	if (path.endsWith('.json')) return 'json';
+	if (path.endsWith('.yaml') || path.endsWith('.yml')) return 'yaml';
+	return 'json';
+}
+
+/**
+ * Deep merge two objects (right overwrites left)
+ */
+export function deepMerge<T extends Record<string, any>>(target: T, source: Partial<T>): T {
+	const result = { ...target };
+
+	for (const key in source) {
+		const sourceValue = source[key];
+		const targetValue = result[key];
+
+		if (sourceValue === undefined) {
+			continue;
+		}
+
+		if (
+			isPlainObject(sourceValue) &&
+			isPlainObject(targetValue) &&
+			!isEncryptedValue(targetValue)
+		) {
+			result[key] = deepMerge(targetValue, sourceValue) as T[Extract<keyof T, string>];
+		} else {
+			result[key] = sourceValue as T[Extract<keyof T, string>];
+		}
+	}
+
+	return result;
+}
+
+function isPlainObject(value: unknown): value is Record<string, any> {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		!Array.isArray(value) &&
+		Object.getPrototypeOf(value) === Object.prototype
+	);
+}
+
+function isEncryptedValue(value: unknown): boolean {
+	return (
+		typeof value === 'object' &&
+		value !== null &&
+		'_encrypted' in value &&
+		(value as { _encrypted?: unknown })._encrypted === true
+	);
+}
+
+const SENSITIVE_KEY_PATTERNS = [
+	'token',
+	'key',
+	'secret',
+	'password',
+	'auth',
+	'api',
+	'credential',
+	'cert',
+	'private'
+];
+
+/**
+ * Check if a key should be treated as sensitive
+ */
+export function isSensitiveKey(key: string): boolean {
+	const lowerKey = key.toLowerCase();
+	if (lowerKey === 'authtype' || lowerKey.endsWith('.authtype')) {
+		return false;
+	}
+	return SENSITIVE_KEY_PATTERNS.some((pattern) => lowerKey.includes(pattern));
+}
+
+/**
+ * Detect secrets in a config object
+ */
+export function detectSecrets(
+	config: Record<string, any>,
+	sourcePath: string,
+	keyPath = ''
+): SecretDetection[] {
+	const secrets: SecretDetection[] = [];
+
+	for (const [key, value] of Object.entries(config)) {
+		const fullKey = keyPath ? `${keyPath}.${key}` : key;
+
+		if (typeof value === 'string' && isSensitiveKey(fullKey) && value.length > 0) {
+			const pattern =
+				SENSITIVE_KEY_PATTERNS.find((p) => fullKey.toLowerCase().includes(p)) || 'unknown';
+
+			secrets.push({
+				key: fullKey,
+				value,
+				source: sourcePath,
+				pattern
+			});
+		} else if (isPlainObject(value)) {
+			secrets.push(...detectSecrets(value, sourcePath, fullKey));
+		}
+	}
+
+	return secrets;
+}
+
+/**
+ * Get a nested value from an object using dot notation
+ */
+export function getNestedValue(obj: Record<string, unknown>, path: string): unknown {
+	const keys = path.split('.');
+	let current: unknown = obj;
+
+	for (const key of keys) {
+		if (current && typeof current === 'object' && key in current) {
+			current = (current as Record<string, unknown>)[key];
+		} else {
+			return undefined;
+		}
+	}
+
+	return current;
+}
+
+/**
+ * Set a nested value in an object using dot notation
+ */
+export function setNestedValue(obj: Record<string, unknown>, path: string, value: unknown): void {
+	const keys = path.split('.');
+	let current: Record<string, unknown> = obj;
+
+	for (let i = 0; i < keys.length - 1; i++) {
+		const key = keys[i];
+		if (!(key in current) || typeof current[key] !== 'object') {
+			current[key] = {};
+		}
+		current = current[key] as Record<string, unknown>;
+	}
+
+	current[keys[keys.length - 1]] = value;
+}
+
+/**
+ * Check if a file exists
+ */
+export async function fileExists(path: string): Promise<boolean> {
+	try {
+		const file = Bun.file(path);
+		return await file.exists();
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Ensure directory exists
+ */
+export async function ensureDir(dirPath: string): Promise<void> {
+	await Bun.spawn(['mkdir', '-p', dirPath], { stderr: 'ignore' }).exited;
+}

package/src/loader/client.ts

@@ -0,0 +1,140 @@
+/**
+ * Client Config Loader
+ *
+ * Browser-safe config loading (defaults + storage only).
+ * Skips filesystem discovery and file loading.
+ */
+
+import type { z } from 'zod/v4';
+import type { ConfigLoadResult, LoadedConfigSource, LoadOptions } from './types.ts';
+import {
+	createDefaultsSource,
+	createStorageSource,
+	mergeConfigSources,
+	mergeConfigSourcesWithValidation,
+	mergeRecordConfigs
+} from './merge.ts';
+import { resolveDefaults } from '../form/core/field-resolver.ts';
+
+function createDefaultSource<T>(options: LoadOptions<T>): LoadedConfigSource<T> | null {
+	const { manifest, includeDefaults = true, defaults } = options;
+	if (!includeDefaults) return null;
+
+	const resolvedDefaults =
+		defaults ??
+		(resolveDefaults(manifest, {
+			hardware: 'consumer',
+			environment: 'development',
+			surface: 'web',
+			isAuthenticated: false,
+			enabledFeatures: new Set(),
+			get: () => undefined,
+			custom: {}
+		}) as T);
+
+	if (!resolvedDefaults || Object.keys(resolvedDefaults as object).length === 0) {
+		return null;
+	}
+
+	return createDefaultsSource<T>(resolvedDefaults);
+}
+
+async function createStorageSourceFromAdapter<T>(
+	options: LoadOptions<T>
+): Promise<{ source: LoadedConfigSource<T> | null; data: T | null }> {
+	const { includeStorage = true, storageAdapter } = options;
+	if (!includeStorage || !storageAdapter) {
+		return { source: null, data: null };
+	}
+
+	try {
+		const data = await storageAdapter.load();
+		const source = createStorageSource<T>(data);
+		return { source, data };
+	} catch (error) {
+		console.warn(`[ConfigLoader] Failed to load from storage: ${error}`);
+		return { source: null, data: null };
+	}
+}
+
+/**
+ * Load config from defaults + storage (client-safe).
+ */
+export async function loadConfigFromManifest<
+	T extends Record<string, unknown> = Record<string, unknown>
+>(options: LoadOptions<T>): Promise<ConfigLoadResult<T>> {
+	const sources: LoadedConfigSource<T>[] = [];
+	const mergedSources: LoadedConfigSource<T>[] = [];
+
+	const defaultSource = createDefaultSource(options);
+	if (defaultSource) {
+		sources.push(defaultSource);
+		mergedSources.push(defaultSource);
+	}
+
+	const { source: storageSource, data: storageData } =
+		await createStorageSourceFromAdapter(options);
+	if (storageSource) {
+		sources.push(storageSource);
+		mergedSources.push(storageSource);
+	}
+
+	let data: T;
+	let validationIssues: Map<string, { path: (string | number)[]; message: string }[]> | undefined;
+
+	if (options.validateGracefully && options.manifest.schema) {
+		const schema = options.manifest.schema as z.ZodType<T>;
+		const result = mergeConfigSourcesWithValidation(mergedSources, schema);
+		data = result.data;
+		validationIssues = result.issues;
+		if (options.onValidationIssues) {
+			for (const [source, issues] of result.issues) {
+				options.onValidationIssues(source, issues);
+			}
+		}
+	} else {
+		data = mergeConfigSources(mergedSources);
+	}
+
+	return {
+		data,
+		sources,
+		mergedSources,
+		hasFileSources: false,
+		hasStorageData: storageData !== null,
+		validationIssues
+	};
+}
+
+/**
+ * Load record config from defaults + storage (client-safe).
+ */
+export async function loadRecordConfigFromManifest<T extends { id: string }>(
+	options: LoadOptions<Record<string, T>>
+): Promise<ConfigLoadResult<Record<string, T>>> {
+	const sources: LoadedConfigSource<Record<string, T>>[] = [];
+	const mergedSources: LoadedConfigSource<Record<string, T>>[] = [];
+
+	const defaultSource = createDefaultSource(options);
+	if (defaultSource) {
+		sources.push(defaultSource);
+		mergedSources.push(defaultSource);
+	}
+
+	const { source: storageSource, data: storageData } =
+		await createStorageSourceFromAdapter(options);
+	if (storageSource) {
+		sources.push(storageSource);
+		mergedSources.push(storageSource);
+	}
+
+	const data = mergeRecordConfigs(mergedSources as LoadedConfigSource<Record<string, T> | T[]>[]);
+
+	return {
+		data,
+		sources,
+		mergedSources,
+		hasFileSources: false,
+		hasStorageData: storageData !== null
+	};
+}