@vibesdotdev/config 0.0.1

package/src/services/loader/loader.impl.consumer.local-first.ts

@@ -0,0 +1,417 @@
+/**
+ * Config Loader - Local-First Implementation
+ *
+ * Hybrid configuration loading using runtime-composed strategy.
+ * Implements local-first policy through runtime resolution, not internal branching.
+ *
+ * Scope: { hardware: ['consumer'], qualifiers: { storage: 'local-first' }}
+ *
+ * This replaces the syncDirection branching in UnifiedConfigLoader with a pure
+ * runtime-composed approach. The cloud client is resolved via runtime.query when needed.
+ */
+
+import { createRuntimeImplementation, getVibesRuntime } from '@vibesdotdev/runtime';
+import type { ConfigManifest } from '../../manifest/types.ts';
+import type { VibesRuntime } from '@vibesdotdev/runtime';
+import type { ConfigLoaderInterface, LoadResult, SaveResult } from './loader.descriptor.ts';
+import type { StorageDocumentStoreInterface } from '@vibesdotdev/storage/interfaces';
+import * as z from 'zod/v4';
+
+/** Local storage adapter interface */
+interface LocalConfigStorageAdapter<T> {
+	load(): Promise<T | null>;
+	save(data: T): Promise<void>;
+	exists(): Promise<boolean>;
+	delete(): Promise<void>;
+}
+
+/** Deferred LocalDB adapter - loads the real adapter dynamically */
+function createDeferredLocalDBAdapter<T>(options: {
+	scope: 'project' | 'global';
+	namespace: string;
+	encrypt?: boolean;
+}): LocalConfigStorageAdapter<T> {
+	let docStore: StorageDocumentStoreInterface<T> | null = null;
+
+	async function getDocStore(): Promise<StorageDocumentStoreInterface<T>> {
+		if (!docStore) {
+			interface AdapterModule {
+				default: {
+					impl: {
+						configure(config: { basePath: string }): void;
+						documentStore<U>(
+							namespace: string,
+							schema: z.ZodType<U>
+						): StorageDocumentStoreInterface<U>;
+					};
+				};
+			}
+			const modulePath = '@vibesdotdev/storage-adapter-localdb/localdb.adapter.impl';
+			const { default: implementation } = (await import(
+				/* @vite-ignore */ modulePath
+			)) as AdapterModule;
+			const adapter = implementation.impl;
+
+			const basePath =
+				options.scope === 'project'
+					? `${process.cwd()}/.vibes`
+					: `${process.env.HOME ?? '~'}/.vibes`;
+
+			adapter.configure({ basePath });
+
+			docStore = adapter.documentStore<T>(options.namespace, z.unknown() as z.ZodType<T>);
+		}
+		return docStore;
+	}
+
+	return {
+		async load(): Promise<T | null> {
+			const store = await getDocStore();
+			return store.load();
+		},
+		async save(data: T): Promise<void> {
+			const store = await getDocStore();
+			return store.save(data);
+		},
+		async exists(): Promise<boolean> {
+			const store = await getDocStore();
+			return store.exists();
+		},
+		async delete(): Promise<void> {
+			const store = await getDocStore();
+			return store.delete();
+		}
+	};
+}
+
+/** Cloud client interface - resolved from runtime */
+interface CloudSettingsClient {
+	get<T>(namespace: string): Promise<T | null>;
+	set<T>(namespace: string, data: T): Promise<void>;
+	delete(namespace: string): Promise<void>;
+}
+
+/** Create a fetch-based cloud settings client */
+function createFetchCloudClient(options: {
+	baseUrl: string;
+	getAuthToken: () => Promise<string | null>;
+}): CloudSettingsClient {
+	const { baseUrl, getAuthToken } = options;
+
+	return {
+		async get<T>(namespace: string): Promise<T | null> {
+			const token = await getAuthToken();
+			if (!token) return null;
+
+			const res = await fetch(`${baseUrl}/api/settings/${encodeURIComponent(namespace)}`, {
+				headers: { Authorization: `Bearer ${token}` }
+			});
+
+			if (!res.ok) return null;
+			return res.json() as Promise<T>;
+		},
+
+		async set<T>(namespace: string, data: T): Promise<void> {
+			const token = await getAuthToken();
+			if (!token) throw new Error('Not authenticated');
+
+			await fetch(`${baseUrl}/api/settings/${encodeURIComponent(namespace)}`, {
+				method: 'PUT',
+				headers: {
+					'Content-Type': 'application/json',
+					Authorization: `Bearer ${token}`
+				},
+				body: JSON.stringify(data)
+			});
+		},
+
+		async delete(namespace: string): Promise<void> {
+			const token = await getAuthToken();
+			if (!token) throw new Error('Not authenticated');
+
+			await fetch(`${baseUrl}/api/settings/${encodeURIComponent(namespace)}`, {
+				method: 'DELETE',
+				headers: { Authorization: `Bearer ${token}` }
+			});
+		}
+	};
+}
+
+/**
+ * Local-First Config Loader
+ *
+ * Hybrid implementation that composes local and cloud storage through runtime.
+ * No internal branching - cloud client is resolved via runtime.query.
+ *
+ * Load strategy: local first, then cloud (with optional caching)
+ * Save strategy: local always, cloud when authenticated
+ */
+export class LocalFirstConfigLoader implements ConfigLoaderInterface {
+	private runtime: VibesRuntime;
+	private localAdapters = new Map<string, LocalConfigStorageAdapter<unknown>>();
+
+	constructor() {
+		this.runtime = getVibesRuntime();
+	}
+
+	/**
+	 * Resolve cloud client from runtime when needed
+	 * Returns null if cloud is not available (not authenticated)
+	 */
+	private async resolveCloudClient(): Promise<CloudSettingsClient | null> {
+		try {
+			// Query runtime for cloud storage adapter
+			const cloudAdapter = await this.runtime
+				.query('storage/adapter')
+				.matching({
+					qualifiers: { type: 'cloud', purpose: 'settings' }
+				})
+				.resolve();
+
+			if (cloudAdapter && typeof cloudAdapter === 'object') {
+				// Check if it has document store capabilities
+				if ('documentStore' in cloudAdapter) {
+					return this.wrapAdapterAsCloudClient(cloudAdapter);
+				}
+			}
+
+			// Fallback: try to resolve from context/config
+			try {
+				const configContext = await this.runtime.context<{
+					cloudBaseUrl?: string;
+					getAuthToken?: () => Promise<string | null>;
+				}>('config');
+				if (configContext && typeof configContext === 'object') {
+					const baseUrl = configContext.cloudBaseUrl;
+					const getAuthToken = configContext.getAuthToken;
+					if (baseUrl && getAuthToken) {
+						return createFetchCloudClient({ baseUrl, getAuthToken });
+					}
+				}
+			} catch {
+				// Config context not available
+			}
+		} catch {
+			// Cloud not available
+		}
+
+		return null;
+	}
+
+	/**
+	 * Wrap a storage adapter as cloud client interface
+	 */
+	private wrapAdapterAsCloudClient(adapter: object): CloudSettingsClient {
+		return {
+			async get<T>(namespace: string): Promise<T | null> {
+				// The adapter already has namespace baked in via documentStore()
+				const store = (adapter as { load?: () => Promise<T | null> }).load;
+				if (store) {
+					return store.call(adapter);
+				}
+				return null;
+			},
+			async set<T>(namespace: string, data: T): Promise<void> {
+				const save = (adapter as { save?: (data: T) => Promise<void> }).save;
+				if (save) {
+					return save.call(adapter, data);
+				}
+			},
+			async delete(namespace: string): Promise<void> {
+				const del = (adapter as { delete?: () => Promise<void> }).delete;
+				if (del) {
+					return del.call(adapter);
+				}
+			}
+		};
+	}
+
+	/**
+	 * Load configuration: local first, then cloud
+	 */
+	async load<T>(manifest: ConfigManifest): Promise<LoadResult<T>> {
+		const namespace = manifest.storage.namespace;
+
+		try {
+			// Step 1: Try local first
+			const localAdapter = this.getLocalAdapter<T>(namespace, manifest);
+			const localData = await localAdapter.load();
+
+			if (localData !== null) {
+				return {
+					data: localData,
+					source: 'local',
+					inSync: true,
+					lastSyncedAt: null
+				};
+			}
+
+			// Step 2: Local empty, try cloud (resolved via runtime)
+			const cloudClient = await this.resolveCloudClient();
+			if (cloudClient) {
+				const cloudData = await cloudClient.get<T>(namespace);
+				if (cloudData !== null) {
+					// Cache to local for future loads
+					await localAdapter.save(cloudData);
+					return {
+						data: cloudData,
+						source: 'cloud',
+						inSync: true,
+						lastSyncedAt: new Date()
+					};
+				}
+			}
+
+			// Step 3: Neither has data
+			return {
+				data: null,
+				source: 'default',
+				inSync: true,
+				lastSyncedAt: null
+			};
+		} catch (error) {
+			return {
+				data: null,
+				source: 'default',
+				inSync: false,
+				lastSyncedAt: null,
+				syncError: error instanceof Error ? error.message : 'Load failed'
+			};
+		}
+	}
+
+	/**
+	 * Save configuration: local always, cloud when available
+	 */
+	async save<T>(manifest: ConfigManifest, data: T): Promise<SaveResult> {
+		const namespace = manifest.storage.namespace;
+
+		try {
+			// Step 1: Save to local
+			const localAdapter = this.getLocalAdapter<T>(namespace, manifest);
+			await localAdapter.save(data);
+
+			// Step 2: Try to sync to cloud (resolved via runtime)
+			const cloudClient = await this.resolveCloudClient();
+			if (cloudClient) {
+				await cloudClient.set(namespace, data);
+				return {
+					success: true,
+					direction: 'push',
+					changesApplied: 1
+				};
+			}
+
+			// No cloud available, local-only save
+			return {
+				success: true,
+				direction: 'none',
+				changesApplied: 1
+			};
+		} catch (error) {
+			return {
+				success: false,
+				direction: 'none',
+				changesApplied: 0,
+				error: error instanceof Error ? error.message : 'Save failed'
+			};
+		}
+	}
+
+	/**
+	 * Sync between local and cloud
+	 */
+	async sync(
+		manifest: ConfigManifest,
+		direction: 'push' | 'pull' | 'auto' = 'auto'
+	): Promise<SaveResult> {
+		const namespace = manifest.storage.namespace;
+
+		try {
+			const localAdapter = this.getLocalAdapter<unknown>(namespace, manifest);
+			const cloudClient = await this.resolveCloudClient();
+
+			if (!cloudClient) {
+				return {
+					success: true,
+					direction: 'none',
+					changesApplied: 0
+				};
+			}
+
+			const localData = await localAdapter.load();
+			const cloudData = await cloudClient.get(namespace);
+
+			// Determine actual direction
+			let actualDirection = direction;
+			if (direction === 'auto') {
+				// Prefer local if it exists (CLI edits take precedence)
+				actualDirection = localData !== null ? 'push' : 'pull';
+			}
+
+			if (actualDirection === 'push' && localData !== null) {
+				await cloudClient.set(namespace, localData);
+				return {
+					success: true,
+					direction: 'push',
+					changesApplied: 1
+				};
+			} else if (actualDirection === 'pull' && cloudData !== null) {
+				await localAdapter.save(cloudData);
+				return {
+					success: true,
+					direction: 'pull',
+					changesApplied: 1
+				};
+			}
+
+			return {
+				success: true,
+				direction: 'none',
+				changesApplied: 0
+			};
+		} catch (error) {
+			return {
+				success: false,
+				direction: 'none',
+				changesApplied: 0,
+				error: error instanceof Error ? error.message : 'Sync failed'
+			};
+		}
+	}
+
+	// Private helpers
+
+	private getLocalAdapter<T>(
+		namespace: string,
+		manifest: ConfigManifest
+	): LocalConfigStorageAdapter<T> {
+		let adapter = this.localAdapters.get(namespace);
+		if (!adapter) {
+			adapter = createDeferredLocalDBAdapter({
+				scope: manifest.storage.scope === 'project' ? 'project' : 'global',
+				namespace,
+				encrypt: manifest.storage.encryptSensitive
+			});
+			this.localAdapters.set(namespace, adapter);
+		}
+		return adapter as LocalConfigStorageAdapter<T>;
+	}
+}
+
+/**
+ * Runtime implementation registration
+ *
+ * Scope: consumer hardware with local-first storage qualifier.
+ * No syncDirection parameter - the qualifier encodes the policy.
+ * Cloud resolved through runtime.query, not internal composition.
+ */
+export default createRuntimeImplementation({
+	kind: 'config/loader',
+	id: 'config.loader.local-first',
+	implementation: LocalFirstConfigLoader,
+	constraint: {
+		hardware: ['consumer'],
+		qualifiers: { storage: 'local-first' }
+	}
+});

package/src/services/loader/loader.impl.consumer.ts

@@ -0,0 +1,213 @@
+/**
+ * Config Loader - Consumer Implementation
+ *
+ * Local-only configuration loading using LocalDB storage.
+ * Single-purpose: handles local persistence only, no cloud logic.
+ *
+ * Scope: { hardware: ['consumer'], qualifiers: { storage: 'local' }}
+ *
+ * This replaces the branching logic in UnifiedConfigLoader with a pure
+ * runtime-selected implementation.
+ */
+
+import { createRuntimeImplementation } from '@vibesdotdev/runtime';
+import type { ConfigManifest } from '../../manifest/types.ts';
+import type { StorageDocumentStoreInterface } from '@vibesdotdev/storage/interfaces';
+import * as z from 'zod/v4';
+import type { ConfigLoaderInterface, LoadResult, SaveResult } from './loader.descriptor.ts';
+
+/** Simple local storage adapter interface */
+interface LocalConfigStorageAdapter<T> {
+	load(): Promise<T | null>;
+	save(data: T): Promise<void>;
+	exists(): Promise<boolean>;
+	delete(): Promise<void>;
+}
+
+/** Deferred LocalDB adapter - loads the real adapter dynamically */
+function createDeferredLocalDBAdapter<T>(options: {
+	scope: 'project' | 'global';
+	namespace: string;
+	encrypt?: boolean;
+}): LocalConfigStorageAdapter<T> {
+	let docStore: StorageDocumentStoreInterface<T> | null = null;
+
+	async function getDocStore(): Promise<StorageDocumentStoreInterface<T>> {
+		if (!docStore) {
+			interface AdapterModule {
+				default: {
+					impl: {
+						configure(config: { basePath: string }): void;
+						documentStore<U>(
+							namespace: string,
+							schema: z.ZodType<U>
+						): StorageDocumentStoreInterface<U>;
+					};
+				};
+			}
+			const modulePath = '@vibesdotdev/storage-adapter-localdb/localdb.adapter.impl';
+			const { default: implementation } = (await import(
+				/* @vite-ignore */ modulePath
+			)) as AdapterModule;
+			const adapter = implementation.impl;
+
+			const basePath =
+				options.scope === 'project'
+					? `${process.cwd()}/.vibes`
+					: `${process.env.HOME ?? '~'}/.vibes`;
+
+			adapter.configure({ basePath });
+
+			docStore = adapter.documentStore<T>(options.namespace, z.unknown() as z.ZodType<T>);
+		}
+		return docStore;
+	}
+
+	return {
+		async load(): Promise<T | null> {
+			const store = await getDocStore();
+			return store.load();
+		},
+		async save(data: T): Promise<void> {
+			const store = await getDocStore();
+			return store.save(data);
+		},
+		async exists(): Promise<boolean> {
+			const store = await getDocStore();
+			return store.exists();
+		},
+		async delete(): Promise<void> {
+			const store = await getDocStore();
+			return store.delete();
+		}
+	};
+}
+
+/**
+ * Local Config Loader
+ *
+ * Single-purpose implementation for local-only configuration.
+ * No cloud dependencies. No syncDirection. No branching logic.
+ */
+export class LocalConfigLoader implements ConfigLoaderInterface {
+	private adapters = new Map<string, LocalConfigStorageAdapter<unknown>>();
+
+	/**
+	 * Load configuration from local storage only
+	 */
+	async load<T>(manifest: ConfigManifest): Promise<LoadResult<T>> {
+		const namespace = manifest.storage.namespace;
+
+		try {
+			const adapter = this.getAdapter<T>(namespace, manifest);
+			const data = await adapter.load();
+
+			return {
+				data,
+				source: data !== null ? 'local' : 'default',
+				inSync: true,
+				lastSyncedAt: null
+			};
+		} catch (error) {
+			return {
+				data: null,
+				source: 'default',
+				inSync: false,
+				lastSyncedAt: null,
+				syncError: error instanceof Error ? error.message : 'Load failed'
+			};
+		}
+	}
+
+	/**
+	 * Save configuration to local storage only
+	 */
+	async save<T>(manifest: ConfigManifest, data: T): Promise<SaveResult> {
+		const namespace = manifest.storage.namespace;
+
+		try {
+			const adapter = this.getAdapter<T>(namespace, manifest);
+			await adapter.save(data);
+
+			return {
+				success: true,
+				direction: 'none',
+				changesApplied: 1
+			};
+		} catch (error) {
+			return {
+				success: false,
+				direction: 'none',
+				changesApplied: 0,
+				error: error instanceof Error ? error.message : 'Save failed'
+			};
+		}
+	}
+
+	/**
+	 * Delete configuration from local storage
+	 */
+	async delete(manifest: ConfigManifest): Promise<SaveResult> {
+		const namespace = manifest.storage.namespace;
+
+		try {
+			const adapter = this.getAdapter<unknown>(namespace, manifest);
+			await adapter.delete();
+
+			this.adapters.delete(namespace);
+
+			return {
+				success: true,
+				direction: 'none',
+				changesApplied: 1
+			};
+		} catch (error) {
+			return {
+				success: false,
+				direction: 'none',
+				changesApplied: 0,
+				error: error instanceof Error ? error.message : 'Delete failed'
+			};
+		}
+	}
+
+	/**
+	 * Check if configuration exists locally
+	 */
+	async exists(manifest: ConfigManifest): Promise<boolean> {
+		const namespace = manifest.storage.namespace;
+		const adapter = this.getAdapter<unknown>(namespace, manifest);
+		return adapter.exists();
+	}
+
+	// Private helpers
+
+	private getAdapter<T>(namespace: string, manifest: ConfigManifest): LocalConfigStorageAdapter<T> {
+		let adapter = this.adapters.get(namespace);
+		if (!adapter) {
+			adapter = createDeferredLocalDBAdapter({
+				scope: manifest.storage.scope === 'project' ? 'project' : 'global',
+				namespace,
+				encrypt: manifest.storage.encryptSensitive
+			});
+			this.adapters.set(namespace, adapter);
+		}
+		return adapter as LocalConfigStorageAdapter<T>;
+	}
+}
+
+/**
+ * Runtime implementation registration
+ *
+ * Scope: consumer hardware with local storage qualifier.
+ * No syncDirection. No cloud dependencies. Single-purpose.
+ */
+export default createRuntimeImplementation({
+	kind: 'config/loader',
+	id: 'config.loader.local',
+	implementation: LocalConfigLoader,
+	constraint: {
+		hardware: ['consumer'],
+		qualifiers: { storage: 'local' }
+	}
+});