btca-server 1.0.962 → 2.0.1

package/src/resources/service.ts

@@ -1,6 +1,8 @@
 import { createHash } from 'node:crypto';
 
-import { Config } from '../config/index.ts';
+import { Effect } from 'effect';
+
+import type { ConfigService as ConfigServiceShape } from '../config/index.ts';
 import { parseNpmReference, validateGitUrl } from '../validation/index.ts';
 import { CommonHints } from '../errors.ts';
 
@@ -33,135 +35,174 @@ export const createAnonymousDirectoryKey = (reference: string): string => {
 
 const isAnonymousResource = (name: string): boolean => name.startsWith(ANON_PREFIX);
 
-export namespace Resources {
-	export type Service = {
-		load: (
-			name: string,
-			options?: {
-				quiet?: boolean;
-			}
-		) => Promise<BtcaFsResource>;
-	};
+export type ResourcesService = {
+	load: (
+		name: string,
+		options?: {
+			quiet?: boolean;
+		}
+	) => Promise<BtcaFsResource>;
+	loadEffect: (
+		name: string,
+		options?: {
+			quiet?: boolean;
+		}
+	) => Effect.Effect<BtcaFsResource, ResourceError>;
+};
 
-	const normalizeSearchPaths = (definition: GitResource): string[] => {
-		const paths = [
-			...(definition.searchPaths ?? []),
-			...(definition.searchPath ? [definition.searchPath] : [])
-		];
-		return paths.filter((path) => path.trim().length > 0);
-	};
+const normalizeSearchPaths = (definition: GitResource): string[] => {
+	const paths = [
+		...(definition.searchPaths ?? []),
+		...(definition.searchPath ? [definition.searchPath] : [])
+	];
+	return paths.filter((path) => path.trim().length > 0);
+};
 
-	const definitionToGitArgs = (
-		definition: GitResource,
-		resourcesDirectory: string,
-		quiet: boolean
-	): BtcaGitResourceArgs => ({
-		type: 'git',
+const definitionToGitArgs = (
+	definition: GitResource,
+	resourcesDirectory: string,
+	quiet: boolean
+): BtcaGitResourceArgs => ({
+	type: 'git',
+	name: definition.name,
+	url: definition.url,
+	branch: definition.branch,
+	repoSubPaths: normalizeSearchPaths(definition),
+	resourcesDirectoryPath: resourcesDirectory,
+	specialAgentInstructions: definition.specialNotes ?? '',
+	quiet,
+	ephemeral: isAnonymousResource(definition.name),
+	localDirectoryKey: isAnonymousResource(definition.name)
+		? createAnonymousDirectoryKey(definition.url)
+		: undefined
+});
+
+const definitionToLocalArgs = (definition: LocalResource): BtcaLocalResourceArgs => ({
+	type: 'local',
+	name: definition.name,
+	path: definition.path,
+	specialAgentInstructions: definition.specialNotes ?? ''
+});
+
+const definitionToNpmArgs = (
+	definition: NpmResource,
+	resourcesDirectory: string
+): BtcaNpmResourceArgs => {
+	const reference = `${definition.package}${definition.version ? `@${definition.version}` : ''}`;
+	return {
+		type: 'npm',
 		name: definition.name,
-		url: definition.url,
-		branch: definition.branch,
-		repoSubPaths: normalizeSearchPaths(definition),
+		package: definition.package,
+		...(definition.version ? { version: definition.version } : {}),
 		resourcesDirectoryPath: resourcesDirectory,
 		specialAgentInstructions: definition.specialNotes ?? '',
-		quiet,
 		ephemeral: isAnonymousResource(definition.name),
 		localDirectoryKey: isAnonymousResource(definition.name)
-			? createAnonymousDirectoryKey(definition.url)
+			? createAnonymousDirectoryKey(reference)
 			: undefined
-	});
-
-	const definitionToLocalArgs = (definition: LocalResource): BtcaLocalResourceArgs => ({
-		type: 'local',
-		name: definition.name,
-		path: definition.path,
-		specialAgentInstructions: definition.specialNotes ?? ''
-	});
+	};
+};
 
-	const definitionToNpmArgs = (
-		definition: NpmResource,
-		resourcesDirectory: string
-	): BtcaNpmResourceArgs => {
-		const reference = `${definition.package}${definition.version ? `@${definition.version}` : ''}`;
+const loadLocalResource = (args: BtcaLocalResourceArgs): BtcaFsResource => ({
+	_tag: 'fs-based',
+	name: args.name,
+	fsName: resourceNameToKey(args.name),
+	type: 'local',
+	repoSubPaths: [],
+	specialAgentInstructions: args.specialAgentInstructions,
+	getAbsoluteDirectoryPath: async () => args.path
+});
+
+export const createAnonymousResource = (reference: string): ResourceDefinition | null => {
+	const npmReference = parseNpmReference(reference);
+	if (npmReference) {
 		return {
 			type: 'npm',
-			name: definition.name,
-			package: definition.package,
-			...(definition.version ? { version: definition.version } : {}),
-			resourcesDirectoryPath: resourcesDirectory,
-			specialAgentInstructions: definition.specialNotes ?? '',
-			ephemeral: isAnonymousResource(definition.name),
-			localDirectoryKey: isAnonymousResource(definition.name)
-				? createAnonymousDirectoryKey(reference)
-				: undefined
+			name: `${ANON_PREFIX}${npmReference.normalizedReference}`,
+			package: npmReference.packageName,
+			...(npmReference.version ? { version: npmReference.version } : {})
 		};
-	};
-
-	const loadLocalResource = (args: BtcaLocalResourceArgs): BtcaFsResource => ({
-		_tag: 'fs-based',
-		name: args.name,
-		fsName: resourceNameToKey(args.name),
-		type: 'local',
-		repoSubPaths: [],
-		specialAgentInstructions: args.specialAgentInstructions,
-		getAbsoluteDirectoryPath: async () => args.path
-	});
+	}
 
-	export const createAnonymousResource = (reference: string): ResourceDefinition | null => {
-		const npmReference = parseNpmReference(reference);
-		if (npmReference) {
-			return {
-				type: 'npm',
-				name: `${ANON_PREFIX}${npmReference.normalizedReference}`,
-				package: npmReference.packageName,
-				...(npmReference.version ? { version: npmReference.version } : {})
-			};
-		}
-
-		const gitUrlResult = validateGitUrl(reference);
-		if (gitUrlResult.valid) {
-			const normalizedUrl = gitUrlResult.value;
-			return {
-				type: 'git',
-				name: `${ANON_PREFIX}${normalizedUrl}`,
-				url: normalizedUrl,
-				branch: DEFAULT_ANON_BRANCH
-			};
-		}
-		return null;
-	};
+	const gitUrlResult = validateGitUrl(reference);
+	if (gitUrlResult.valid) {
+		const normalizedUrl = gitUrlResult.value;
+		return {
+			type: 'git',
+			name: `${ANON_PREFIX}${normalizedUrl}`,
+			url: normalizedUrl,
+			branch: DEFAULT_ANON_BRANCH
+		};
+	}
+	return null;
+};
 
-	export const resolveResourceDefinition = (
-		reference: string,
-		getResource: Config.Service['getResource']
-	): ResourceDefinition => {
-		const definition = getResource(reference);
-		if (definition) return definition;
+export const resolveResourceDefinition = (
+	reference: string,
+	getResource: ConfigServiceShape['getResource']
+): ResourceDefinition => {
+	const definition = getResource(reference);
+	if (definition) return definition;
 
-		const anonymousDefinition = createAnonymousResource(reference);
-		if (anonymousDefinition) return anonymousDefinition;
+	const anonymousDefinition = createAnonymousResource(reference);
+	if (anonymousDefinition) return anonymousDefinition;
 
-		throw new ResourceError({
-			message: `Resource "${reference}" not found in config`,
-			hint: `${CommonHints.LIST_RESOURCES} ${CommonHints.ADD_RESOURCE}`
-		});
-	};
+	throw new ResourceError({
+		message: `Resource "${reference}" not found in config`,
+		hint: `${CommonHints.LIST_RESOURCES} ${CommonHints.ADD_RESOURCE}`
+	});
+};
 
-	export const create = (config: Config.Service): Service => {
-		return {
-			load: async (name, options) => {
-				const quiet = options?.quiet ?? false;
-				const definition = resolveResourceDefinition(name, config.getResource);
+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
+								})
+				});
+			}
 
-				if (isGitResource(definition)) {
-					return loadGitResource(definitionToGitArgs(definition, config.resourcesDirectory, quiet));
-				}
+			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)) {
-					return loadNpmResource(definitionToNpmArgs(definition, config.resourcesDirectory));
-				}
+			return loadLocalResource(definitionToLocalArgs(definition));
+		});
 
-				return loadLocalResource(definitionToLocalArgs(definition));
-			}
-		};
+	return {
+		load: (name, options) => Effect.runPromise(loadEffect(name, options)),
+		loadEffect
 	};
-}
+};

package/src/stream/index.ts

@@ -1,4 +1,4 @@
-export { StreamService } from './service.ts';
+export { createSseStream } from './service.ts';
 export {
 	BtcaStreamEventSchema,
 	BtcaStreamMetaEventSchema,

package/src/stream/service.test.ts

@@ -1,6 +1,6 @@
 import { describe, it, expect } from 'bun:test';
 
-import { StreamService } from './service.ts';
+import { createSseStream } from './service.ts';
 import type { BtcaStreamEvent } from './types.ts';
 
 const readStream = async (stream: ReadableStream<Uint8Array>) => {
@@ -22,7 +22,7 @@ const parseSseEvents = (payload: string) =>
 		.filter((line): line is string => Boolean(line))
 		.map((line) => JSON.parse(line.slice(6)) as BtcaStreamEvent);
 
-describe('StreamService.createSseStream', () => {
+describe('createSseStream', () => {
 	it('streams reasoning deltas and includes final reasoning in done', async () => {
 		const eventStream = (async function* () {
 			yield { type: 'reasoning-delta', text: 'First ' } as const;
@@ -31,7 +31,7 @@ describe('StreamService.createSseStream', () => {
 			yield { type: 'finish', finishReason: 'stop' } as const;
 		})();
 
-		const stream = StreamService.createSseStream({
+		const stream = createSseStream({
 			meta: {
 				type: 'meta',
 				model: { provider: 'test', model: 'test-model' },
@@ -71,7 +71,7 @@ describe('StreamService.createSseStream', () => {
 			} as const;
 		})();
 
-		const stream = StreamService.createSseStream({
+		const stream = createSseStream({
 			meta: {
 				type: 'meta',
 				model: { provider: 'openrouter', model: 'openai/gpt-4o-mini' },
@@ -124,7 +124,7 @@ describe('StreamService.createSseStream', () => {
 			yield { type: 'finish', finishReason: 'stop' } as const;
 		})();
 
-		const stream = StreamService.createSseStream({
+		const stream = createSseStream({
 			meta: {
 				type: 'meta',
 				model: { provider: 'test', model: 'test-model' },