btca-server 2.0.2 → 2.0.4

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);

package/src/resources/service.ts

@@ -41,13 +41,13 @@ export type ResourcesService = {
 		options?: {
 			quiet?: boolean;
 		}
-	) => Promise<BtcaFsResource>;
-	loadEffect: (
+	) => Effect.Effect<BtcaFsResource, ResourceError, never>;
+	loadPromise: (
 		name: string,
 		options?: {
 			quiet?: boolean;
 		}
-	) => Effect.Effect<BtcaFsResource, ResourceError>;
+	) => Promise<BtcaFsResource>;
 };
 
 const normalizeSearchPaths = (definition: GitResource): string[] => {
@@ -154,55 +154,56 @@ export const resolveResourceDefinition = (
 };
 
 export const createResourcesService = (config: ConfigServiceShape): ResourcesService => {
-	const loadEffect: ResourcesService['loadEffect'] = (name, options) =>
-		Effect.gen(function* () {
-			const quiet = options?.quiet ?? false;
-			const definition = yield* Effect.try({
-				try: () => resolveResourceDefinition(name, config.getResource),
-				catch: (cause) =>
-					cause instanceof ResourceError
-						? cause
-						: new ResourceError({
-								message: `Failed to resolve resource "${name}"`,
-								hint: `${CommonHints.LIST_RESOURCES} ${CommonHints.ADD_RESOURCE}`,
-								cause
-							})
-			});
-
-			if (isGitResource(definition)) {
-				return yield* Effect.tryPromise({
-					try: () =>
-						loadGitResource(definitionToGitArgs(definition, config.resourcesDirectory, quiet)),
-					catch: (cause) =>
-						cause instanceof ResourceError
-							? cause
-							: new ResourceError({
-									message: `Failed to load git resource "${name}"`,
-									hint: CommonHints.CLEAR_CACHE,
-									cause
-								})
+	const loadPromise: ResourcesService['loadPromise'] = async (name, options) => {
+		const quiet = options?.quiet ?? false;
+		const definition = resolveResourceDefinition(name, config.getResource);
+
+		if (isGitResource(definition)) {
+			try {
+				return await loadGitResource(
+					definitionToGitArgs(definition, config.resourcesDirectory, quiet)
+				);
+			} catch (cause) {
+				if (cause instanceof ResourceError) throw cause;
+				throw new ResourceError({
+					message: `Failed to load git resource "${name}"`,
+					hint: CommonHints.CLEAR_CACHE,
+					cause
 				});
 			}
+		}
 
-			if (isNpmResource(definition)) {
-				return yield* Effect.tryPromise({
-					try: () => loadNpmResource(definitionToNpmArgs(definition, config.resourcesDirectory)),
-					catch: (cause) =>
-						cause instanceof ResourceError
-							? cause
-							: new ResourceError({
-									message: `Failed to load npm resource "${name}"`,
-									hint: CommonHints.CLEAR_CACHE,
-									cause
-								})
+		if (isNpmResource(definition)) {
+			try {
+				return await loadNpmResource(definitionToNpmArgs(definition, config.resourcesDirectory));
+			} catch (cause) {
+				if (cause instanceof ResourceError) throw cause;
+				throw new ResourceError({
+					message: `Failed to load npm resource "${name}"`,
+					hint: CommonHints.CLEAR_CACHE,
+					cause
 				});
 			}
+		}
+
+		return loadLocalResource(definitionToLocalArgs(definition));
+	};
 
-			return loadLocalResource(definitionToLocalArgs(definition));
+	const load: ResourcesService['load'] = (name, options) =>
+		Effect.tryPromise({
+			try: () => loadPromise(name, options),
+			catch: (cause) =>
+				cause instanceof ResourceError
+					? cause
+					: new ResourceError({
+							message: `Failed to resolve resource "${name}"`,
+							hint: `${CommonHints.LIST_RESOURCES} ${CommonHints.ADD_RESOURCE}`,
+							cause
+						})
 		});
 
 	return {
-		load: (name, options) => Effect.runPromise(loadEffect(name, options)),
-		loadEffect
+		load,
+		loadPromise
 	};
 };