@vibesdotdev/config 0.0.1

package/src/loader/discovery.ts

@@ -0,0 +1,291 @@
+/**
+ * Config File Discovery
+ *
+ * Discovers config files across all scopes and formats.
+ * Searches:
+ * - Global: ~/.vibes/{namespace}.{ts,js,json,jsonc,yaml}
+ * - Local: ./.vibes/{namespace}.{ts,js,json,jsonc,yaml}
+ * - Project: ./vibes.{namespace}.{ts,js,json,jsonc,yaml}
+ *
+ * NOTE: This file uses lazy-loaded Node.js modules to avoid
+ * Vite/Rollup bundler issues when the file is analyzed for client builds.
+ * The actual imports happen at runtime when functions are called.
+ */
+
+import { getRuntimeEnv } from '@vibesdotdev/runtime';
+
+// Lazy-loaded Node.js modules to avoid bundler issues
+let _join: typeof import('path').join | null = null;
+let _homedir: typeof import('os').homedir | null = null;
+
+async function getJoin(): Promise<typeof import('path').join> {
+	if (!_join) {
+		const path = await import('path');
+		_join = path.join;
+	}
+	return _join;
+}
+
+async function getHomedir(): Promise<typeof import('os').homedir> {
+	if (!_homedir) {
+		const os = await import('os');
+		_homedir = os.homedir;
+	}
+	return _homedir;
+}
+
+import {
+	type ConfigFileFormat,
+	type ConfigFileScope,
+	type ConfigPriority,
+	type DiscoveredConfigFile,
+	type DiscoveryOptions,
+	CONFIG_PRIORITIES
+} from './types.ts';
+
+/**
+ * All supported file extensions in priority order
+ * (TypeScript highest priority as it's most expressive)
+ */
+const FORMAT_EXTENSIONS: ConfigFileFormat[] = ['ts', 'js', 'json', 'jsonc', 'yaml'];
+
+/**
+ * YAML file extensions
+ */
+const YAML_EXTENSIONS = ['yaml', 'yml'];
+
+/**
+ * Get the global vibes directory. Profile-aware: when VIBES_PROFILE is set,
+ * resolves to ~/.vibes/profile/{profile}/.
+ */
+export async function getVibesDir(): Promise<string> {
+	const join = await getJoin();
+	const homedir = await getHomedir();
+	const profile = getRuntimeEnv('VIBES_PROFILE') || getRuntimeEnv('VIBES_PROFILE_NAME');
+	if (profile) {
+		return join(homedir(), '.vibes', 'profile', profile);
+	}
+	return join(homedir(), '.vibes');
+}
+
+/**
+ * Generate all possible file paths for a namespace and scope
+ */
+async function getPathsForScope(
+	namespace: string,
+	scope: ConfigFileScope,
+	cwd: string
+): Promise<{ path: string; format: ConfigFileFormat }[]> {
+	const join = await getJoin();
+	const paths: { path: string; format: ConfigFileFormat }[] = [];
+
+	switch (scope) {
+		case 'global': {
+			// ~/.vibes/{namespace}.{ext}
+			const dir = await getVibesDir();
+			for (const format of FORMAT_EXTENSIONS) {
+				if (format === 'yaml') {
+					// Support both .yaml and .yml
+					for (const ext of YAML_EXTENSIONS) {
+						paths.push({ path: join(dir, `${namespace}.${ext}`), format: 'yaml' });
+					}
+				} else {
+					paths.push({ path: join(dir, `${namespace}.${format}`), format });
+				}
+			}
+			break;
+		}
+
+		case 'local': {
+			// ./.vibes/{namespace}.{ext}
+			const dir = join(cwd, '.vibes');
+			for (const format of FORMAT_EXTENSIONS) {
+				if (format === 'yaml') {
+					for (const ext of YAML_EXTENSIONS) {
+						paths.push({ path: join(dir, `${namespace}.${ext}`), format: 'yaml' });
+					}
+				} else {
+					paths.push({ path: join(dir, `${namespace}.${format}`), format });
+				}
+			}
+			break;
+		}
+
+		case 'project': {
+			// ./vibes.{namespace}.{ext}
+			for (const format of FORMAT_EXTENSIONS) {
+				if (format === 'yaml') {
+					for (const ext of YAML_EXTENSIONS) {
+						paths.push({ path: join(cwd, `vibes.${namespace}.${ext}`), format: 'yaml' });
+					}
+				} else {
+					paths.push({ path: join(cwd, `vibes.${namespace}.${format}`), format });
+				}
+			}
+			break;
+		}
+	}
+
+	return paths;
+}
+
+/**
+ * Get priority for a scope
+ */
+function getPriorityForScope(scope: ConfigFileScope): ConfigPriority {
+	switch (scope) {
+		case 'global':
+			return CONFIG_PRIORITIES.GLOBAL;
+		case 'local':
+			return CONFIG_PRIORITIES.LOCAL;
+		case 'project':
+			return CONFIG_PRIORITIES.PROJECT;
+	}
+}
+
+/**
+ * Check if a file exists
+ */
+async function fileExists(path: string): Promise<boolean> {
+	try {
+		const file = Bun.file(path);
+		return await file.exists();
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Discover all config files for a namespace
+ *
+ * Returns files in priority order (lowest to highest).
+ * Only returns files that exist.
+ *
+ * @example
+ * ```ts
+ * const files = await discoverConfigFiles({
+ *   namespace: 'autoloop',
+ *   scopes: ['global', 'local', 'project'],
+ * });
+ * // Returns existing files like:
+ * // - ~/.vibes/autoloop.json (priority 1)
+ * // - ./.vibes/autoloop.ts (priority 2)
+ * // - ./vibes.autoloop.ts (priority 3)
+ * ```
+ */
+export async function discoverConfigFiles(
+	options: DiscoveryOptions
+): Promise<DiscoveredConfigFile[]> {
+	const {
+		namespace,
+		scopes = ['global', 'local', 'project'],
+		patterns = [],
+		fallbackPatterns = [],
+		cwd = process.cwd()
+	} = options;
+
+	const discovered: DiscoveredConfigFile[] = [];
+	const checkedPaths = new Set<string>();
+
+	// Check standard paths for each scope
+	for (const scope of scopes) {
+		const scopePaths = await getPathsForScope(namespace, scope, cwd);
+		const priority = getPriorityForScope(scope);
+
+		// Find first existing file for this scope (highest format priority)
+		for (const { path, format } of scopePaths) {
+			if (checkedPaths.has(path)) continue;
+			checkedPaths.add(path);
+
+			const exists = await fileExists(path);
+			if (exists) {
+				discovered.push({
+					path,
+					format,
+					scope,
+					priority,
+					exists: true
+				});
+				// Only take first existing file per scope (highest format priority)
+				break;
+			}
+		}
+	}
+
+	// Check custom patterns (project-level priority)
+	const join = await getJoin();
+	for (const pattern of patterns) {
+		const path = pattern.startsWith('/') ? pattern : join(cwd, pattern);
+		if (checkedPaths.has(path)) continue;
+		checkedPaths.add(path);
+
+		const exists = await fileExists(path);
+		if (exists) {
+			const format = detectFormat(path);
+			discovered.push({
+				path,
+				format,
+				scope: 'project',
+				priority: CONFIG_PRIORITIES.PROJECT,
+				exists: true
+			});
+		}
+	}
+
+	// Check fallback patterns if no files found yet
+	if (discovered.length === 0) {
+		for (const pattern of fallbackPatterns) {
+			const path = pattern.startsWith('/') ? pattern : join(cwd, pattern);
+			if (checkedPaths.has(path)) continue;
+			checkedPaths.add(path);
+
+			const exists = await fileExists(path);
+			if (exists) {
+				const format = detectFormat(path);
+				discovered.push({
+					path,
+					format,
+					scope: 'project',
+					priority: CONFIG_PRIORITIES.PROJECT,
+					exists: true
+				});
+				break; // Only use first fallback found
+			}
+		}
+	}
+
+	// Sort by priority (lowest to highest for merge order)
+	discovered.sort((a, b) => a.priority - b.priority);
+
+	return discovered;
+}
+
+/**
+ * Detect file format from path
+ */
+export function detectFormat(path: string): ConfigFileFormat {
+	const lower = path.toLowerCase();
+	if (lower.endsWith('.ts')) return 'ts';
+	if (lower.endsWith('.js') || lower.endsWith('.mjs') || lower.endsWith('.cjs')) return 'js';
+	if (lower.endsWith('.jsonc')) return 'jsonc';
+	if (lower.endsWith('.json')) return 'json';
+	if (lower.endsWith('.yaml') || lower.endsWith('.yml')) return 'yaml';
+	return 'json'; // Default
+}
+
+/**
+ * Get all search paths that would be checked for a namespace
+ * (useful for error messages and debugging)
+ */
+export async function getAllSearchPaths(
+	namespace: string,
+	scopes: ConfigFileScope[] = ['global', 'local', 'project'],
+	cwd: string = process.cwd()
+): Promise<string[]> {
+	const paths: string[] = [];
+	for (const scope of scopes) {
+		const scopePaths = await getPathsForScope(namespace, scope, cwd);
+		paths.push(...scopePaths.map((p) => p.path));
+	}
+	return paths;
+}

package/src/loader/file-loader.ts

@@ -0,0 +1,262 @@
+/// <reference path="../js-yaml.d.ts" />
+
+/**
+ * Config File Loader
+ *
+ * Loads config files in various formats (ts/js/json/jsonc/yaml).
+ * Handles dynamic imports for TypeScript/JavaScript files.
+ */
+
+import type { DiscoveredConfigFile, LoadedConfigSource } from './types.ts';
+import type { ConfigFileLocation } from '../manifest/types.ts';
+import { detectFormat } from './discovery.ts';
+
+/**
+ * Load a config file and return its contents
+ */
+export async function loadConfigFile<T = unknown>(
+	file: DiscoveredConfigFile,
+	configFileLocation?: ConfigFileLocation
+): Promise<LoadedConfigSource<T>> {
+	const { path, format, scope, priority } = file;
+
+	try {
+		let data: T;
+
+		switch (format) {
+			case 'ts':
+			case 'js':
+				data = await loadTsJsFile<T>(path, configFileLocation);
+				break;
+
+			case 'json':
+				data = await loadJsonFile<T>(path);
+				break;
+
+			case 'jsonc':
+				data = await loadJsoncFile<T>(path);
+				break;
+
+			case 'yaml':
+				data = await loadYamlFile<T>(path);
+				break;
+
+			default:
+				throw new Error(`Unsupported format: ${format}`);
+		}
+
+		return {
+			source: path,
+			scope,
+			priority,
+			data,
+			format,
+			loaded: true
+		};
+	} catch (error) {
+		return {
+			source: path,
+			scope,
+			priority,
+			data: {} as T,
+			format,
+			loaded: false,
+			error: error instanceof Error ? error.message : String(error)
+		};
+	}
+}
+
+/**
+ * Load a TypeScript or JavaScript config file
+ */
+async function loadTsJsFile<T>(path: string, configFileLocation?: ConfigFileLocation): Promise<T> {
+	// Dynamic import the module
+	let module: Record<string, unknown>;
+	try {
+		// Add timestamp to bust cache for development
+		const importPath = `${path}?t=${Date.now()}`;
+		module = await import(importPath);
+	} catch (importError) {
+		const msg = importError instanceof Error ? importError.message : String(importError);
+		throw new Error(`Failed to import ${path}: ${msg}`);
+	}
+
+	// Determine which export to use
+	const exportName = configFileLocation?.exportName;
+	let result: unknown;
+
+	// Try explicit export name
+	if (exportName && exportName !== 'default') {
+		result = module[exportName];
+		if (result === undefined) {
+			throw new Error(`Export '${exportName}' not found in ${path}`);
+		}
+	}
+	// Try default export
+	else if (module.default !== undefined) {
+		result = module.default;
+	}
+	// Try configs export (for record-type manifests)
+	else if (configFileLocation?.configsExport && module[configFileLocation.configsExport]) {
+		result = module[configFileLocation.configsExport];
+	}
+	// Try common export names
+	else if (module.config !== undefined) {
+		result = module.config;
+	} else if (module.configs !== undefined) {
+		result = module.configs;
+	}
+	// Use entire module if it looks like a config object
+	else {
+		// Filter out module metadata
+		const { __esModule, ...rest } = module as Record<string, unknown>;
+		if (Object.keys(rest).length > 0) {
+			result = rest;
+		} else {
+			throw new Error(`No valid export found in ${path}`);
+		}
+	}
+
+	// If result is a function, call it (supports factory configs)
+	if (typeof result === 'function') {
+		try {
+			result = await result();
+		} catch (execError) {
+			const msg = execError instanceof Error ? execError.message : String(execError);
+			throw new Error(`Failed to execute config factory in ${path}: ${msg}`);
+		}
+	}
+
+	return result as T;
+}
+
+/**
+ * Load a JSON config file
+ */
+async function loadJsonFile<T>(path: string): Promise<T> {
+	const file = Bun.file(path);
+	const content = await file.text();
+	return JSON.parse(content) as T;
+}
+
+/**
+ * Load a JSONC (JSON with comments) config file
+ */
+async function loadJsoncFile<T>(path: string): Promise<T> {
+	const file = Bun.file(path);
+	const content = await file.text();
+	// Strip comments (single-line // and multi-line /* */)
+	const stripped = content
+		.replace(/\/\/.*$/gm, '') // Single-line comments
+		.replace(/\/\*[\s\S]*?\*\//g, ''); // Multi-line comments
+	return JSON.parse(stripped) as T;
+}
+
+/**
+ * Load a YAML config file
+ */
+async function loadYamlFile<T>(path: string): Promise<T> {
+	const file = Bun.file(path);
+	const content = await file.text();
+
+	// Use js-yaml for parsing (bundled with Bun)
+	try {
+		const yaml = await import('js-yaml');
+		return yaml.load(content) as T;
+	} catch (_yamlError) {
+		// Fallback: try simple YAML parsing for basic configs
+		return parseSimpleYaml<T>(content);
+	}
+}
+
+/**
+ * Simple YAML parser for basic key-value configs
+ * Falls back to this if js-yaml isn't available
+ */
+function parseSimpleYaml<T>(content: string): T {
+	const result: Record<string, unknown> = {};
+	const lines = content.split('\n');
+	const _currentIndent = 0;
+	let currentObj = result;
+	const stack: { obj: Record<string, unknown>; indent: number }[] = [{ obj: result, indent: 0 }];
+
+	for (const line of lines) {
+		// Skip empty lines and comments
+		const trimmed = line.trim();
+		if (!trimmed || trimmed.startsWith('#')) continue;
+
+		// Calculate indent
+		const indent = line.search(/\S/);
+
+		// Pop stack if we're at a lower indent level
+		while (stack.length > 1 && indent <= stack[stack.length - 1].indent) {
+			stack.pop();
+		}
+		currentObj = stack[stack.length - 1].obj;
+
+		// Parse key: value
+		const colonIndex = trimmed.indexOf(':');
+		if (colonIndex === -1) continue;
+
+		const key = trimmed.slice(0, colonIndex).trim();
+		const value = trimmed.slice(colonIndex + 1).trim();
+
+		if (value === '' || value === '|' || value === '>') {
+			// Nested object or multiline string
+			currentObj[key] = {};
+			stack.push({ obj: currentObj[key] as Record<string, unknown>, indent });
+		} else {
+			// Parse value
+			currentObj[key] = parseYamlValue(value);
+		}
+	}
+
+	return result as T;
+}
+
+/**
+ * Parse a YAML value
+ */
+function parseYamlValue(value: string): unknown {
+	// Remove quotes
+	if (
+		(value.startsWith('"') && value.endsWith('"')) ||
+		(value.startsWith("'") && value.endsWith("'"))
+	) {
+		return value.slice(1, -1);
+	}
+	// Boolean
+	if (value === 'true') return true;
+	if (value === 'false') return false;
+	// Null
+	if (value === 'null' || value === '~') return null;
+	// Number
+	const num = Number(value);
+	if (!isNaN(num) && value !== '') return num;
+	// String
+	return value;
+}
+
+/**
+ * Load a config file from a path (auto-detect format)
+ */
+export async function loadConfigFromPath<T = unknown>(
+	path: string,
+	configFileLocation?: ConfigFileLocation
+): Promise<T> {
+	const format = detectFormat(path);
+	const file: DiscoveredConfigFile = {
+		path,
+		format,
+		scope: 'project',
+		priority: 3,
+		exists: true
+	};
+
+	const result = await loadConfigFile<T>(file, configFileLocation);
+	if (!result.loaded) {
+		throw new Error(result.error || `Failed to load ${path}`);
+	}
+
+	return result.data;
+}