btca-server 2.0.2 → 2.0.3

package/src/config/config.test.ts

@@ -2,6 +2,7 @@ import { describe, it, expect, beforeEach, afterEach } from 'bun:test';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import os from 'node:os';
+import { Effect } from 'effect';
 
 import {
 	load as loadConfig,
@@ -380,12 +381,14 @@ describe('Config', () => {
 			expect(config.resources.length).toBe(3);
 
 			// Add a new resource
-			await config.addResource({
-				name: 'new-resource',
-				type: 'git',
-				url: 'https://github.com/test/new-resource',
-				branch: 'main'
-			});
+			await Effect.runPromise(
+				config.addResource({
+					name: 'new-resource',
+					type: 'git',
+					url: 'https://github.com/test/new-resource',
+					branch: 'main'
+				})
+			);
 
 			// Verify merged state shows 4 resources
 			expect(config.resources.length).toBe(4);
@@ -459,7 +462,7 @@ describe('Config', () => {
 			expect(config.resources.length).toBe(3);
 
 			// Remove the project resource
-			await config.removeResource('myproject');
+			await Effect.runPromise(config.removeResource('myproject'));
 
 			// Verify merged state shows 2 resources (only global)
 			expect(config.resources.length).toBe(2);
@@ -477,7 +480,7 @@ describe('Config', () => {
 			).toBeUndefined();
 
 			// Trying to remove a global resource should throw an error
-			expect(config.removeResource('svelte')).rejects.toThrow(
+			expect(Effect.runPromise(config.removeResource('svelte'))).rejects.toThrow(
 				'Resource "svelte" is defined in the global config'
 			);
 
@@ -528,7 +531,7 @@ describe('Config', () => {
 			// Update the model
 			const nextProvider = 'openrouter';
 			const nextModel = 'openai/gpt-4o-mini';
-			await config.updateModel(nextProvider, nextModel);
+			await Effect.runPromise(config.updateModel(nextProvider, nextModel));
 
 			expect(config.provider).toBe(nextProvider);
 			expect(config.model).toBe(nextModel);
@@ -574,12 +577,14 @@ describe('Config', () => {
 			const config = await Config.load();
 
 			// Add a resource (should go to global)
-			await config.addResource({
-				name: 'new-resource',
-				type: 'git',
-				url: 'https://github.com/test/new-resource',
-				branch: 'main'
-			});
+			await Effect.runPromise(
+				config.addResource({
+					name: 'new-resource',
+					type: 'git',
+					url: 'https://github.com/test/new-resource',
+					branch: 'main'
+				})
+			);
 
 			expect(config.resources.length).toBe(2);
 
@@ -592,7 +597,7 @@ describe('Config', () => {
 			]);
 
 			// Remove a resource (should work since we're in global-only mode)
-			await config.removeResource('svelte');
+			await Effect.runPromise(config.removeResource('svelte'));
 			expect(config.resources.length).toBe(1);
 
 			const savedGlobalConfig2 = JSON.parse(await fs.readFile(globalConfigPath, 'utf-8'));

package/src/config/index.ts

@@ -141,20 +141,11 @@ export type ConfigService = {
 		provider: string,
 		model: string,
 		providerOptions?: ProviderOptionsConfig
-	) => Promise<{ provider: string; model: string; savedTo: ConfigScope }>;
-	updateModelEffect: (
-		provider: string,
-		model: string,
-		providerOptions?: ProviderOptionsConfig
 	) => Effect.Effect<{ provider: string; model: string; savedTo: ConfigScope }, unknown>;
-	addResource: (resource: ResourceDefinition) => Promise<ResourceDefinition>;
-	addResourceEffect: (resource: ResourceDefinition) => Effect.Effect<ResourceDefinition, unknown>;
-	removeResource: (name: string) => Promise<void>;
-	removeResourceEffect: (name: string) => Effect.Effect<void, unknown>;
-	clearResources: () => Promise<{ cleared: number }>;
-	clearResourcesEffect: () => Effect.Effect<{ cleared: number }, unknown>;
-	reload: () => Promise<void>;
-	reloadEffect: () => Effect.Effect<void, unknown>;
+	addResource: (resource: ResourceDefinition) => Effect.Effect<ResourceDefinition, unknown>;
+	removeResource: (name: string) => Effect.Effect<void, unknown>;
+	clearResources: () => Effect.Effect<{ cleared: number }, unknown>;
+	reload: () => Effect.Effect<void, unknown>;
 };
 
 export type Service = ConfigService;
@@ -495,234 +486,222 @@ const makeService = (
 		}
 	};
 
-	const service: ConfigService = {
-		resourcesDirectory,
-		configPath,
-		get resources() {
-			return getMergedResources();
-		},
-		get model() {
-			return getActiveConfig().model ?? DEFAULT_MODEL;
-		},
-		get provider() {
-			return getActiveConfig().provider ?? DEFAULT_PROVIDER;
-		},
-		get providerTimeoutMs() {
-			return getActiveConfig().providerTimeoutMs;
-		},
-		get maxSteps() {
-			return getActiveConfig().maxSteps ?? DEFAULT_MAX_STEPS;
-		},
-		getProviderOptions: (providerId: string) => getMergedProviderOptions()[providerId],
-		getResource: (name: string) => getMergedResources().find((r) => r.name === name),
+	const updateModelPromise = async (
+		provider: string,
+		model: string,
+		providerOptions?: ProviderOptionsConfig
+	): Promise<{ provider: string; model: string; savedTo: ConfigScope }> => {
+		if (!isProviderSupported(provider)) {
+			const available = getSupportedProviders();
+			throw new ConfigError({
+				message: `Provider "${provider}" is not supported`,
+				hint: `Available providers: ${available.join(', ')}. Open an issue to request this provider: https://github.com/davis7dotsh/better-context/issues.`
+			});
+		}
+		const mutableConfig = getMutableConfig();
+		const existingProviderOptions = mutableConfig.providerOptions ?? {};
+		const nextProviderOptions = providerOptions
+			? {
+					...existingProviderOptions,
+					[provider]: {
+						...(existingProviderOptions[provider] ?? {}),
+						...providerOptions
+					}
+				}
+			: existingProviderOptions;
+		const updated = {
+			...mutableConfig,
+			provider,
+			model,
+			...(providerOptions ? { providerOptions: nextProviderOptions } : {})
+		};
 
-		updateModel: async (
-			provider: string,
-			model: string,
-			providerOptions?: ProviderOptionsConfig
-		) => {
-			if (!isProviderSupported(provider)) {
-				const available = getSupportedProviders();
+		if (provider === 'openai-compat') {
+			const merged = currentProjectConfig
+				? mergeProviderOptions(currentGlobalConfig, updated)
+				: mergeProviderOptions(updated, null);
+			const compat = merged['openai-compat'];
+			const baseURL = compat?.baseURL?.trim();
+			const name = compat?.name?.trim();
+			if (!baseURL || !name) {
 				throw new ConfigError({
-					message: `Provider "${provider}" is not supported`,
-					hint: `Available providers: ${available.join(', ')}. Open an issue to request this provider: https://github.com/davis7dotsh/better-context/issues.`
+					message: 'openai-compat requires baseURL and name',
+					hint: 'Run "btca connect -p openai-compat" to configure baseURL and name.'
 				});
 			}
-			const mutableConfig = getMutableConfig();
-			const existingProviderOptions = mutableConfig.providerOptions ?? {};
-			const nextProviderOptions = providerOptions
-				? {
-						...existingProviderOptions,
-						[provider]: {
-							...(existingProviderOptions[provider] ?? {}),
-							...providerOptions
-						}
-					}
-				: existingProviderOptions;
-			const updated = {
-				...mutableConfig,
-				provider,
-				model,
-				...(providerOptions ? { providerOptions: nextProviderOptions } : {})
-			};
+		}
+		setMutableConfig(updated);
+		await saveConfig(configPath, updated);
+		metricsInfo('config.model.updated', { provider, model });
+		return {
+			provider,
+			model,
+			savedTo: currentProjectConfig ? 'project' : 'global'
+		};
+	};
 
-			if (provider === 'openai-compat') {
-				const merged = currentProjectConfig
-					? mergeProviderOptions(currentGlobalConfig, updated)
-					: mergeProviderOptions(updated, null);
-				const compat = merged['openai-compat'];
-				const baseURL = compat?.baseURL?.trim();
-				const name = compat?.name?.trim();
-				if (!baseURL || !name) {
-					throw new ConfigError({
-						message: 'openai-compat requires baseURL and name',
-						hint: 'Run "btca connect -p openai-compat" to configure baseURL and name.'
-					});
-				}
-			}
-			setMutableConfig(updated);
-			await saveConfig(configPath, updated);
-			metricsInfo('config.model.updated', { provider, model });
-			return {
-				provider,
-				model,
-				savedTo: currentProjectConfig ? 'project' : 'global'
-			};
-		},
+	const addResourcePromise = async (resource: ResourceDefinition): Promise<ResourceDefinition> => {
+		const mergedResources = getMergedResources();
+		if (mergedResources.some((r) => r.name === resource.name)) {
+			throw new ConfigError({
+				message: `Resource "${resource.name}" already exists`,
+				hint: `Choose a different name or remove the existing resource first with "btca remove ${resource.name}".`
+			});
+		}
+
+		const mutableConfig = getMutableConfig();
+		const updated = {
+			...mutableConfig,
+			resources: [...mutableConfig.resources, resource]
+		};
+		setMutableConfig(updated);
+		await saveConfig(configPath, updated);
+		metricsInfo('config.resource.added', { name: resource.name, type: resource.type });
+		return resource;
+	};
 
-		addResource: async (resource: ResourceDefinition) => {
-			// Check for duplicate name in merged resources
-			const mergedResources = getMergedResources();
-			if (mergedResources.some((r) => r.name === resource.name)) {
+	const removeResourcePromise = async (name: string): Promise<void> => {
+		const mergedResources = getMergedResources();
+		const exists = mergedResources.some((r) => r.name === name);
+		if (!exists) {
+			const available = mergedResources.map((r) => r.name);
+			throw new ConfigError({
+				message: `Resource "${name}" not found`,
+				hint:
+					available.length > 0
+						? `Available resources: ${available.join(', ')}. ${CommonHints.LIST_RESOURCES}`
+						: `No resources configured. ${CommonHints.ADD_RESOURCE}`
+			});
+		}
+
+		const mutableConfig = getMutableConfig();
+		const isInMutableConfig = mutableConfig.resources.some((r) => r.name === name);
+
+		if (currentProjectConfig) {
+			const isInGlobal = currentGlobalConfig.resources.some((r) => r.name === name);
+			const isInProject = currentProjectConfig.resources.some((r) => r.name === name);
+
+			if (isInProject) {
+				const updated = {
+					...currentProjectConfig,
+					resources: currentProjectConfig.resources.filter((r) => r.name !== name)
+				};
+				currentProjectConfig = updated;
+				await saveConfig(configPath, updated);
+				metricsInfo('config.resource.removed', { name, from: 'project' });
+			} else if (isInGlobal) {
 				throw new ConfigError({
-					message: `Resource "${resource.name}" already exists`,
-					hint: `Choose a different name or remove the existing resource first with "btca remove ${resource.name}".`
+					message: `Resource "${name}" is defined in the global config`,
+					hint: `To remove this resource globally, edit the global config at "${expandHome(GLOBAL_CONFIG_DIR)}/${GLOBAL_CONFIG_FILENAME}" or run the command without a project config present.`
+				});
+			}
+		} else {
+			if (!isInMutableConfig) {
+				throw new ConfigError({
+					message: `Resource "${name}" not found in config`,
+					hint: CommonHints.LIST_RESOURCES
 				});
 			}
-
-			// Add only to the mutable config (project if exists, else global)
-			const mutableConfig = getMutableConfig();
 			const updated = {
 				...mutableConfig,
-				resources: [...mutableConfig.resources, resource]
+				resources: mutableConfig.resources.filter((r) => r.name !== name)
 			};
 			setMutableConfig(updated);
 			await saveConfig(configPath, updated);
-			metricsInfo('config.resource.added', { name: resource.name, type: resource.type });
-			return resource;
-		},
-
-		removeResource: async (name: string) => {
-			const mergedResources = getMergedResources();
-			const exists = mergedResources.some((r) => r.name === name);
-			if (!exists) {
-				const available = mergedResources.map((r) => r.name);
-				throw new ConfigError({
-					message: `Resource "${name}" not found`,
-					hint:
-						available.length > 0
-							? `Available resources: ${available.join(', ')}. ${CommonHints.LIST_RESOURCES}`
-							: `No resources configured. ${CommonHints.ADD_RESOURCE}`
-				});
-			}
+			metricsInfo('config.resource.removed', { name, from: 'global' });
+		}
+	};
 
-			const mutableConfig = getMutableConfig();
-			const isInMutableConfig = mutableConfig.resources.some((r) => r.name === name);
-
-			if (currentProjectConfig) {
-				// We have a project config
-				const isInGlobal = currentGlobalConfig.resources.some((r) => r.name === name);
-				const isInProject = currentProjectConfig.resources.some((r) => r.name === name);
-
-				if (isInProject) {
-					// Resource is in project config - just remove it
-					const updated = {
-						...currentProjectConfig,
-						resources: currentProjectConfig.resources.filter((r) => r.name !== name)
-					};
-					currentProjectConfig = updated;
-					await saveConfig(configPath, updated);
-					metricsInfo('config.resource.removed', { name, from: 'project' });
-				} else if (isInGlobal) {
-					// Resource is only in global config
-					// User wants to remove a global resource from project context
-					// We can't modify global config from project context, so throw an error
-					throw new ConfigError({
-						message: `Resource "${name}" is defined in the global config`,
-						hint: `To remove this resource globally, edit the global config at "${expandHome(GLOBAL_CONFIG_DIR)}/${GLOBAL_CONFIG_FILENAME}" or run the command without a project config present.`
-					});
-				}
-			} else {
-				// No project config, modify global directly
-				if (!isInMutableConfig) {
-					// This shouldn't happen given the exists check above, but be safe
-					throw new ConfigError({
-						message: `Resource "${name}" not found in config`,
-						hint: CommonHints.LIST_RESOURCES
-					});
-				}
-				const updated = {
-					...mutableConfig,
-					resources: mutableConfig.resources.filter((r) => r.name !== name)
-				};
-				setMutableConfig(updated);
-				await saveConfig(configPath, updated);
-				metricsInfo('config.resource.removed', { name, from: 'global' });
-			}
-		},
+	const clearResourcesPromise = async (): Promise<{ cleared: number }> => {
+		let clearedCount = 0;
 
-		clearResources: async () => {
-			// Clear the resources directory
-			let clearedCount = 0;
+		let resourcesDir: string[] = [];
+		try {
+			resourcesDir = await fs.readdir(resourcesDirectory);
+		} catch {
+			resourcesDir = [];
+		}
 
-			let resourcesDir: string[] = [];
+		for (const item of resourcesDir) {
 			try {
-				resourcesDir = await fs.readdir(resourcesDirectory);
+				await fs.rm(`${resourcesDirectory}/${item}`, { recursive: true, force: true });
+				clearedCount++;
 			} catch {
-				resourcesDir = [];
+				break;
 			}
+		}
 
-			for (const item of resourcesDir) {
-				try {
-					await fs.rm(`${resourcesDirectory}/${item}`, { recursive: true, force: true });
-					clearedCount++;
-				} catch {
-					break;
-				}
-			}
+		metricsInfo('config.resources.cleared', { count: clearedCount });
+		return { cleared: clearedCount };
+	};
 
-			metricsInfo('config.resources.cleared', { count: clearedCount });
-			return { cleared: clearedCount };
-		},
+	const reloadPromise = async (): Promise<void> => {
+		metricsInfo('config.reload.start', { configPath });
 
-		reload: async () => {
-			// Reload the config file from disk
-			// configPath points to either project config (if it existed at startup) or global config
-			metricsInfo('config.reload.start', { configPath });
+		const configExists = await Bun.file(configPath).exists();
+		if (!configExists) {
+			metricsInfo('config.reload.skipped', { reason: 'file not found', configPath });
+			return;
+		}
 
-			const configExists = await Bun.file(configPath).exists();
-			if (!configExists) {
-				metricsInfo('config.reload.skipped', { reason: 'file not found', configPath });
-				return;
-			}
+		const reloaded = await loadConfigFromPath(configPath);
 
-			const reloaded = await loadConfigFromPath(configPath);
+		if (currentProjectConfig !== null) {
+			currentProjectConfig = reloaded;
+		} else {
+			currentGlobalConfig = reloaded;
+		}
 
-			// Update the appropriate config based on what we had at startup
-			if (currentProjectConfig !== null) {
-				currentProjectConfig = reloaded;
-			} else {
-				currentGlobalConfig = reloaded;
-			}
+		metricsInfo('config.reload.done', {
+			resources: reloaded.resources.length,
+			configPath
+		});
+	};
 
-			metricsInfo('config.reload.done', {
-				resources: reloaded.resources.length,
-				configPath
-			});
+	const service: ConfigService = {
+		resourcesDirectory,
+		configPath,
+		get resources() {
+			return getMergedResources();
 		},
-		updateModelEffect: (provider, model, providerOptions) =>
+		get model() {
+			return getActiveConfig().model ?? DEFAULT_MODEL;
+		},
+		get provider() {
+			return getActiveConfig().provider ?? DEFAULT_PROVIDER;
+		},
+		get providerTimeoutMs() {
+			return getActiveConfig().providerTimeoutMs;
+		},
+		get maxSteps() {
+			return getActiveConfig().maxSteps ?? DEFAULT_MAX_STEPS;
+		},
+		getProviderOptions: (providerId: string) => getMergedProviderOptions()[providerId],
+		getResource: (name: string) => getMergedResources().find((r) => r.name === name),
+
+		updateModel: (provider, model, providerOptions) =>
 			Effect.tryPromise({
-				try: () => service.updateModel(provider, model, providerOptions),
+				try: () => updateModelPromise(provider, model, providerOptions),
 				catch: (cause) => cause
 			}),
-		addResourceEffect: (resource) =>
+		addResource: (resource) =>
 			Effect.tryPromise({
-				try: () => service.addResource(resource),
+				try: () => addResourcePromise(resource),
 				catch: (cause) => cause
 			}),
-		removeResourceEffect: (name) =>
+		removeResource: (name) =>
 			Effect.tryPromise({
-				try: () => service.removeResource(name),
+				try: () => removeResourcePromise(name),
 				catch: (cause) => cause
 			}),
-		clearResourcesEffect: () =>
+		clearResources: () =>
 			Effect.tryPromise({
-				try: () => service.clearResources(),
+				try: () => clearResourcesPromise(),
 				catch: (cause) => cause
 			}),
-		reloadEffect: () =>
+		reload: () =>
 			Effect.tryPromise({
-				try: () => service.reload(),
+				try: () => reloadPromise(),
 				catch: (cause) => cause
 			})
 	};

package/src/effect/services.ts

@@ -97,58 +97,50 @@ export const getDefaultResourceNames: Effect.Effect<string[], never, ConfigServi
 
 export const reloadConfig: Effect.Effect<void, unknown, ConfigService> = Effect.flatMap(
 	configService,
-	(config) => config.reloadEffect()
+	(config) => config.reload()
 );
 
-export const listProviders: Effect.Effect<
-	Awaited<ReturnType<AgentServiceShape['listProviders']>>,
-	unknown,
-	AgentService
-> = Effect.flatMap(agentService, (agent) => agent.listProvidersEffect());
+export const listProviders = Effect.flatMap(agentService, (agent) => agent.listProviders());
 
 export const loadCollection = (args: {
 	resourceNames: readonly string[];
 	quiet?: boolean;
 }): Effect.Effect<
-	Awaited<ReturnType<CollectionsServiceShape['load']>>,
+	Awaited<ReturnType<CollectionsServiceShape['loadPromise']>>,
 	unknown,
 	CollectionsService
-> => Effect.flatMap(collectionsService, (collections) => collections.loadEffect(args));
+> => Effect.flatMap(collectionsService, (collections) => collections.load(args));
 
 export const askQuestion = (args: {
-	collection: Awaited<ReturnType<CollectionsServiceShape['load']>>;
+	collection: Awaited<ReturnType<CollectionsServiceShape['loadPromise']>>;
 	question: string;
-}): Effect.Effect<Awaited<ReturnType<AgentServiceShape['ask']>>, unknown, AgentService> =>
-	Effect.flatMap(agentService, (agent) => agent.askEffect(args));
+}) => Effect.flatMap(agentService, (agent) => agent.ask(args));
 
 export const askQuestionStream = (args: {
-	collection: Awaited<ReturnType<CollectionsServiceShape['load']>>;
+	collection: Awaited<ReturnType<CollectionsServiceShape['loadPromise']>>;
 	question: string;
-}): Effect.Effect<Awaited<ReturnType<AgentServiceShape['askStream']>>, unknown, AgentService> =>
-	Effect.flatMap(agentService, (agent) => agent.askStreamEffect(args));
+}) => Effect.flatMap(agentService, (agent) => agent.askStream(args));
 
 export const updateModelConfig = (args: {
 	provider: string;
 	model: string;
 	providerOptions?: Parameters<ConfigServiceShape['updateModel']>[2];
-}): Effect.Effect<Awaited<ReturnType<ConfigServiceShape['updateModel']>>, unknown, ConfigService> =>
+}) =>
 	Effect.flatMap(configService, (config) =>
-		config.updateModelEffect(args.provider, args.model, args.providerOptions)
+		config.updateModel(args.provider, args.model, args.providerOptions)
 	);
 
 export const addConfigResource = (
 	resource: ResourceDefinition
 ): Effect.Effect<ResourceDefinition, unknown, ConfigService> =>
-	Effect.flatMap(configService, (config) => config.addResourceEffect(resource));
+	Effect.flatMap(configService, (config) => config.addResource(resource));
 
 export const removeConfigResource = (name: string): Effect.Effect<void, unknown, ConfigService> =>
-	Effect.flatMap(configService, (config) => config.removeResourceEffect(name));
+	Effect.flatMap(configService, (config) => config.removeResource(name));
 
-export const clearConfigResources: Effect.Effect<
-	Awaited<ReturnType<ConfigServiceShape['clearResources']>>,
-	unknown,
-	ConfigService
-> = Effect.flatMap(configService, (config) => config.clearResourcesEffect());
+export const clearConfigResources = Effect.flatMap(configService, (config) =>
+	config.clearResources()
+);
 
 export const loadedResourceCollectionKey = (resourceNames: readonly string[]) =>
 	getCollectionKey(resourceNames);