btca-server 2.0.1 → 2.0.3

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "btca-server",
-	"version": "2.0.1",
+	"version": "2.0.3",
 	"description": "BTCA server for answering questions about your codebase using OpenCode AI",
 	"author": "Ben Davis",
 	"license": "MIT",

package/src/agent/agent.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 { createAgentService } from './service.ts';
 import { load as loadConfig } from '../config/index.ts';
@@ -71,10 +72,12 @@ describe('Agent', () => {
 				vfsId
 			};
 
-			const result = await agent.ask({
-				collection,
-				question: 'What number is the answer to life according to the README?'
-			});
+			const result = await Effect.runPromise(
+				agent.ask({
+					collection,
+					question: 'What number is the answer to life according to the README?'
+				})
+			);
 
 			expect(result).toBeDefined();
 			expect(result.answer).toBeDefined();
@@ -102,10 +105,12 @@ describe('Agent', () => {
 				vfsId
 			};
 
-			const { stream, model } = await agent.askStream({
-				collection,
-				question: 'What is the capital of France according to the data file?'
-			});
+			const { stream, model } = await Effect.runPromise(
+				agent.askStream({
+					collection,
+					question: 'What is the capital of France according to the data file?'
+				})
+			);
 
 			expect(model).toBeDefined();
 			expect(model.provider).toBeDefined();
@@ -154,10 +159,12 @@ describe('Agent', () => {
 				vfsId
 			};
 
-			const result = await agent.ask({
-				collection,
-				question: 'What number is the answer according to the README?'
-			});
+			const result = await Effect.runPromise(
+				agent.ask({
+					collection,
+					question: 'What number is the answer according to the README?'
+				})
+			);
 
 			expect(result).toBeDefined();
 			expect(hasVirtualFs(vfsId)).toBe(false);
@@ -200,10 +207,12 @@ describe('Agent', () => {
 				vfsId
 			};
 
-			const { stream } = await agent.askStream({
-				collection,
-				question: 'What is the capital of France according to the README?'
-			});
+			const { stream } = await Effect.runPromise(
+				agent.askStream({
+					collection,
+					question: 'What is the capital of France according to the README?'
+				})
+			);
 
 			for await (const _event of stream) {
 				// drain stream to trigger cleanup

package/src/agent/service.ts

@@ -87,11 +87,7 @@ export class ProviderNotConnectedError extends Error {
 }
 
 export type AgentService = {
-	askStream: (args: { collection: CollectionResult; question: string }) => Promise<{
-		stream: AsyncIterable<AgentEvent>;
-		model: { provider: string; model: string };
-	}>;
-	askStreamEffect: (args: { collection: CollectionResult; question: string }) => Effect.Effect<
+	askStream: (args: { collection: CollectionResult; question: string }) => Effect.Effect<
 		{
 			stream: AsyncIterable<AgentEvent>;
 			model: { provider: string; model: string };
@@ -99,17 +95,12 @@ export type AgentService = {
 		unknown
 	>;
 
-	ask: (args: { collection: CollectionResult; question: string }) => Promise<AgentResult>;
-	askEffect: (args: {
+	ask: (args: {
 		collection: CollectionResult;
 		question: string;
 	}) => Effect.Effect<AgentResult, unknown>;
 
-	listProviders: () => Promise<{
-		all: { id: string; models: Record<string, unknown> }[];
-		connected: string[];
-	}>;
-	listProvidersEffect: () => Effect.Effect<
+	listProviders: () => Effect.Effect<
 		{
 			all: { id: string; models: Record<string, unknown> }[];
 			connected: string[];
@@ -121,36 +112,39 @@ export type AgentService = {
 export type Service = AgentService;
 
 export const createAgentService = (config: ConfigServiceShape): AgentService => {
-	const cleanupCollection = (collection: CollectionResult) =>
-		Effect.promise(async () => {
-			if (collection.vfsId) {
-				disposeVirtualFs(collection.vfsId);
-				clearVirtualCollectionMetadata(collection.vfsId);
-			}
-			try {
-				await collection.cleanup?.();
-			} catch {
-				return;
-			}
-		});
+	const cleanupCollection = async (collection: CollectionResult) => {
+		if (collection.vfsId) {
+			disposeVirtualFs(collection.vfsId);
+			clearVirtualCollectionMetadata(collection.vfsId);
+		}
+		try {
+			await collection.cleanup?.();
+		} catch {
+			return;
+		}
+	};
 
-	const ensureProviderConnected = Effect.fn(function* () {
-		const isAuthed = yield* Effect.tryPromise(() => isAuthenticated(config.provider));
+	const ensureProviderConnected = async () => {
+		const isAuthed = await isAuthenticated(config.provider);
 		const requiresAuth = config.provider !== 'opencode' && config.provider !== 'openai-compat';
 		if (isAuthed || !requiresAuth) return;
-		const authenticated = yield* Effect.tryPromise(() => getAuthenticatedProviders());
-		yield* Effect.fail(
-			new ProviderNotConnectedError({
-				providerId: config.provider,
-				connectedProviders: authenticated
-			})
-		);
-	});
+		const authenticated = await getAuthenticatedProviders();
+		throw new ProviderNotConnectedError({
+			providerId: config.provider,
+			connectedProviders: authenticated
+		});
+	};
 
 	/**
 	 * Ask a question and stream the response using the new AI SDK loop
 	 */
-	const askStream: AgentService['askStream'] = async ({ collection, question }) => {
+	const askStreamImpl = async ({
+		collection,
+		question
+	}: {
+		collection: CollectionResult;
+		question: string;
+	}) => {
 		metricsInfo('agent.ask.start', {
 			provider: config.provider,
 			model: config.model,
@@ -158,9 +152,9 @@ export const createAgentService = (config: ConfigServiceShape): AgentService =>
 		});
 
 		try {
-			await Effect.runPromise(ensureProviderConnected());
+			await ensureProviderConnected();
 		} catch (error) {
-			await Effect.runPromise(cleanupCollection(collection));
+			await cleanupCollection(collection);
 			throw error;
 		}
 
@@ -181,7 +175,7 @@ export const createAgentService = (config: ConfigServiceShape): AgentService =>
 					yield event;
 				}
 			} finally {
-				await Effect.runPromise(cleanupCollection(collection));
+				await cleanupCollection(collection);
 			}
 		})();
 
@@ -194,103 +188,99 @@ export const createAgentService = (config: ConfigServiceShape): AgentService =>
 	/**
 	 * Ask a question and return the complete response
 	 */
-	const ask: AgentService['ask'] = async ({ collection, question }) => {
-		return Effect.runPromise(
-			Effect.gen(function* () {
-				metricsInfo('agent.ask.start', {
-					provider: config.provider,
-					model: config.model,
-					questionLength: question.length
-				});
+	const askImpl = async ({
+		collection,
+		question
+	}: {
+		collection: CollectionResult;
+		question: string;
+	}) => {
+		try {
+			metricsInfo('agent.ask.start', {
+				provider: config.provider,
+				model: config.model,
+				questionLength: question.length
+			});
 
-				yield* ensureProviderConnected();
+			await ensureProviderConnected();
 
-				const result = yield* Effect.tryPromise({
-					try: () =>
-						runAgentLoop({
-							providerId: config.provider,
-							modelId: config.model,
-							maxSteps: config.maxSteps,
-							collectionPath: collection.path,
-							vfsId: collection.vfsId,
-							agentInstructions: collection.agentInstructions,
-							question,
-							providerOptions: config.getProviderOptions(config.provider)
-						}),
-					catch: (cause) =>
-						new AgentError({
-							message: getErrorMessage(cause),
-							hint:
-								getErrorHint(cause) ??
-								'This may be a temporary issue. Try running the command again.',
-							cause
-						})
+			let result: Awaited<ReturnType<typeof runAgentLoop>>;
+			try {
+				result = await runAgentLoop({
+					providerId: config.provider,
+					modelId: config.model,
+					maxSteps: config.maxSteps,
+					collectionPath: collection.path,
+					vfsId: collection.vfsId,
+					agentInstructions: collection.agentInstructions,
+					question,
+					providerOptions: config.getProviderOptions(config.provider)
 				});
-
-				metricsInfo('agent.ask.complete', {
-					provider: config.provider,
-					model: config.model,
-					answerLength: result.answer.length,
-					eventCount: result.events.length
+			} catch (cause) {
+				throw new AgentError({
+					message: getErrorMessage(cause),
+					hint:
+						getErrorHint(cause) ?? 'This may be a temporary issue. Try running the command again.',
+					cause
 				});
+			}
 
-				return {
-					answer: result.answer,
-					model: result.model,
-					events: result.events
-				};
-			}).pipe(
-				Effect.tapError((error) =>
-					Effect.sync(() => metricsError('agent.ask.error', { error: metricsErrorInfo(error) }))
-				),
-				Effect.ensuring(cleanupCollection(collection))
-			)
-		);
+			metricsInfo('agent.ask.complete', {
+				provider: config.provider,
+				model: config.model,
+				answerLength: result.answer.length,
+				eventCount: result.events.length
+			});
+
+			return {
+				answer: result.answer,
+				model: result.model,
+				events: result.events
+			};
+		} catch (error) {
+			metricsError('agent.ask.error', { error: metricsErrorInfo(error) });
+			throw error;
+		} finally {
+			await cleanupCollection(collection);
+		}
 	};
 
 	/**
 	 * List available providers using local auth data
 	 */
-	const listProviders: AgentService['listProviders'] = async () => {
-		return Effect.runPromise(
-			Effect.gen(function* () {
-				const supportedProviders = getSupportedProviders();
-				const authenticatedProviders = yield* Effect.tryPromise(() => getAuthenticatedProviders());
-				const all = supportedProviders.map((id) => ({
-					id,
-					models: {} as Record<string, unknown>
-				}));
+	const listProvidersImpl = async () => {
+		const supportedProviders = getSupportedProviders();
+		const authenticatedProviders = await getAuthenticatedProviders();
+		const all = supportedProviders.map((id) => ({
+			id,
+			models: {} as Record<string, unknown>
+		}));
 
-				return {
-					all,
-					connected: authenticatedProviders
-				};
-			})
-		);
+		return {
+			all,
+			connected: authenticatedProviders
+		};
 	};
 
-	const askStreamEffect: AgentService['askStreamEffect'] = (args) =>
+	const askStream: AgentService['askStream'] = (args) =>
 		Effect.tryPromise({
-			try: () => askStream(args),
+			try: () => askStreamImpl(args),
 			catch: (cause) => cause
 		});
-	const askEffect: AgentService['askEffect'] = (args) =>
+	const ask: AgentService['ask'] = (args) =>
 		Effect.tryPromise({
-			try: () => ask(args),
+			try: () => askImpl(args),
 			catch: (cause) => cause
 		});
-	const listProvidersEffect: AgentService['listProvidersEffect'] = () =>
+	const listProviders: AgentService['listProviders'] = () =>
 		Effect.tryPromise({
-			try: () => listProviders(),
+			try: () => listProvidersImpl(),
 			catch: (cause) => cause
 		});
 
 	return {
 		askStream,
 		ask,
-		listProviders,
-		askStreamEffect,
-		askEffect,
-		listProvidersEffect
+		listProviders
 	};
 };

package/src/collections/service.test.ts

@@ -0,0 +1,119 @@
+import { describe, expect, it } from 'bun:test';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+import type { ConfigService } from '../config/index.ts';
+import type { ResourcesService } from '../resources/service.ts';
+import { createCollectionsService } from './service.ts';
+import { disposeVirtualFs, existsInVirtualFs } from '../vfs/virtual-fs.ts';
+
+const createLocalResource = (name: string, resourcePath: string) => ({
+	_tag: 'fs-based' as const,
+	name,
+	fsName: name,
+	type: 'local' as const,
+	repoSubPaths: [],
+	specialAgentInstructions: '',
+	getAbsoluteDirectoryPath: async () => resourcePath
+});
+
+const createConfigMock = () =>
+	({
+		getResource: () => undefined
+	}) as unknown as ConfigService;
+
+const createResourcesMock = (resourcePath: string) =>
+	({
+		load: () => {
+			throw new Error('Not implemented in test');
+		},
+		loadPromise: async () => createLocalResource('repo', resourcePath)
+	}) as unknown as ResourcesService;
+
+const runGit = (cwd: string, args: string[]) => {
+	const result = Bun.spawnSync({
+		cmd: ['git', ...args],
+		cwd,
+		stdout: 'pipe',
+		stderr: 'pipe'
+	});
+	if (result.exitCode !== 0) {
+		throw new Error(
+			`git ${args.join(' ')} failed: ${new TextDecoder().decode(result.stderr).trim()}`
+		);
+	}
+};
+
+const cleanupCollection = async (collection: { vfsId?: string; cleanup?: () => Promise<void> }) => {
+	await collection.cleanup?.();
+	if (collection.vfsId) disposeVirtualFs(collection.vfsId);
+};
+
+describe('createCollectionsService', () => {
+	it('imports git-backed local resources from tracked and unignored files only', async () => {
+		const resourcePath = await fs.mkdtemp(path.join(os.tmpdir(), 'btca-collections-git-'));
+		const collections = createCollectionsService({
+			config: createConfigMock(),
+			resources: createResourcesMock(resourcePath)
+		});
+
+		try {
+			await fs.mkdir(path.join(resourcePath, 'node_modules', 'pkg'), { recursive: true });
+			await fs.writeFile(path.join(resourcePath, '.gitignore'), 'node_modules\n');
+			await fs.writeFile(path.join(resourcePath, 'package.json'), '{"name":"repo"}\n');
+			await fs.writeFile(path.join(resourcePath, 'README.md'), 'local notes\n');
+			await fs.writeFile(path.join(resourcePath, 'node_modules', 'pkg', 'index.js'), 'ignored\n');
+
+			runGit(resourcePath, ['init', '-q']);
+			runGit(resourcePath, ['add', '.gitignore', 'package.json']);
+
+			const collection = await collections.loadPromise({ resourceNames: ['repo'] });
+
+			try {
+				expect(await existsInVirtualFs('/repo/package.json', collection.vfsId)).toBe(true);
+				expect(await existsInVirtualFs('/repo/README.md', collection.vfsId)).toBe(true);
+				expect(await existsInVirtualFs('/repo/node_modules/pkg/index.js', collection.vfsId)).toBe(
+					false
+				);
+				expect(await existsInVirtualFs('/repo/.git/config', collection.vfsId)).toBe(false);
+			} finally {
+				await cleanupCollection(collection);
+			}
+		} finally {
+			await fs.rm(resourcePath, { recursive: true, force: true });
+		}
+	});
+
+	it('falls back to directory import and still skips heavy local build directories', async () => {
+		const resourcePath = await fs.mkdtemp(path.join(os.tmpdir(), 'btca-collections-local-'));
+		const collections = createCollectionsService({
+			config: createConfigMock(),
+			resources: createResourcesMock(resourcePath)
+		});
+
+		try {
+			await fs.mkdir(path.join(resourcePath, 'node_modules', 'pkg'), { recursive: true });
+			await fs.mkdir(path.join(resourcePath, 'dist'), { recursive: true });
+			await fs.writeFile(path.join(resourcePath, 'package.json'), '{"name":"repo"}\n');
+			await fs.writeFile(path.join(resourcePath, 'README.md'), 'hello\n');
+			await fs.writeFile(path.join(resourcePath, 'node_modules', 'pkg', 'index.js'), 'ignored\n');
+			await fs.writeFile(path.join(resourcePath, 'dist', 'bundle.js'), 'ignored\n');
+
+			const collection = await collections.loadPromise({ resourceNames: ['repo'] });
+
+			try {
+				expect(await existsInVirtualFs('/repo/package.json', collection.vfsId)).toBe(true);
+				expect(await existsInVirtualFs('/repo/README.md', collection.vfsId)).toBe(true);
+				expect(await existsInVirtualFs('/repo/node_modules/pkg/index.js', collection.vfsId)).toBe(
+					false
+				);
+				expect(await existsInVirtualFs('/repo/dist/bundle.js', collection.vfsId)).toBe(false);
+			} finally {
+				await cleanupCollection(collection);
+			}
+		} finally {
+			await fs.rm(resourcePath, { recursive: true, force: true });
+		}
+	});
+});

package/src/collections/service.ts

@@ -15,6 +15,7 @@ import {
 	createVirtualFs,
 	disposeVirtualFs,
 	importDirectoryIntoVirtualFs,
+	importPathsIntoVirtualFs,
 	mkdirVirtualFs,
 	rmVirtualFs
 } from '../vfs/virtual-fs.ts';
@@ -25,11 +26,14 @@ import {
 } from './virtual-metadata.ts';
 
 export type CollectionsService = {
-	load: (args: { resourceNames: readonly string[]; quiet?: boolean }) => Promise<CollectionResult>;
-	loadEffect: (args: {
+	load: (args: {
 		resourceNames: readonly string[];
 		quiet?: boolean;
-	}) => Effect.Effect<CollectionResult, CollectionError>;
+	}) => Effect.Effect<CollectionResult, CollectionError, never>;
+	loadPromise: (args: {
+		resourceNames: readonly string[];
+		quiet?: boolean;
+	}) => Promise<CollectionResult>;
 };
 
 const encodePathSegments = (value: string) => value.split('/').map(encodeURIComponent).join('/');
@@ -92,6 +96,53 @@ const ignoreErrors = async (action: () => Promise<unknown>) => {
 	}
 };
 
+const LOCAL_RESOURCE_IGNORED_DIRECTORIES = new Set([
+	'.git',
+	'.turbo',
+	'.next',
+	'.svelte-kit',
+	'.vercel',
+	'.cache',
+	'coverage',
+	'dist',
+	'build',
+	'out',
+	'node_modules'
+]);
+
+const normalizeRelativePath = (value: string) => value.split(path.sep).join('/');
+
+const shouldIgnoreImportedPath = (resource: BtcaFsResource, relativePath: string) => {
+	const normalized = normalizeRelativePath(relativePath);
+	if (!normalized || normalized === '.') return false;
+	const segments = normalized.split('/');
+	if (segments.includes('.git')) return true;
+	if (resource.type !== 'local') return false;
+	return segments.some((segment) => LOCAL_RESOURCE_IGNORED_DIRECTORIES.has(segment));
+};
+
+const listGitVisiblePaths = async (resourcePath: string) => {
+	try {
+		const proc = Bun.spawn(
+			['git', 'ls-files', '-z', '--cached', '--others', '--exclude-standard'],
+			{
+				cwd: resourcePath,
+				stdout: 'pipe',
+				stderr: 'ignore'
+			}
+		);
+		const stdout = await new Response(proc.stdout).text();
+		const exitCode = await proc.exited;
+		if (exitCode !== 0) return null;
+		return stdout
+			.split('\0')
+			.map((entry) => entry.trim())
+			.filter((entry) => entry.length > 0);
+	} catch {
+		return null;
+	}
+};
+
 const initVirtualRoot = async (collectionPath: string, vfsId: string) => {
 	try {
 		await mkdirVirtualFs(collectionPath, { recursive: true }, vfsId);
@@ -106,7 +157,7 @@ const initVirtualRoot = async (collectionPath: string, vfsId: string) => {
 
 const loadResource = async (resources: ResourcesService, name: string, quiet: boolean) => {
 	try {
-		return await resources.load(name, { quiet });
+		return await resources.loadPromise(name, { quiet });
 	} catch (cause) {
 		const underlyingHint = getErrorHint(cause);
 		const underlyingMessage = getErrorMessage(cause);
@@ -139,16 +190,24 @@ const virtualizeResource = async (args: {
 	vfsId: string;
 }) => {
 	try {
+		if (args.resource.type === 'local') {
+			const gitVisiblePaths = await listGitVisiblePaths(args.resourcePath);
+			if (gitVisiblePaths) {
+				await importPathsIntoVirtualFs({
+					sourcePath: args.resourcePath,
+					destinationPath: args.virtualResourcePath,
+					relativePaths: gitVisiblePaths,
+					vfsId: args.vfsId
+				});
+				return;
+			}
+		}
+
 		await importDirectoryIntoVirtualFs({
 			sourcePath: args.resourcePath,
 			destinationPath: args.virtualResourcePath,
 			vfsId: args.vfsId,
-			ignore: (relativePath) => {
-				const normalized = relativePath.split(path.sep).join('/');
-				return (
-					normalized === '.git' || normalized.startsWith('.git/') || normalized.includes('/.git/')
-				);
-			}
+			ignore: (relativePath) => shouldIgnoreImportedPath(args.resource, relativePath)
 		});
 	} catch (cause) {
 		throw new CollectionError({
@@ -270,7 +329,7 @@ export const createCollectionsService = (args: {
 	config: ConfigServiceShape;
 	resources: ResourcesService;
 }): CollectionsService => {
-	const load: CollectionsService['load'] = ({ resourceNames, quiet = false }) =>
+	const loadPromise: CollectionsService['loadPromise'] = ({ resourceNames, quiet = false }) =>
 		runTransaction('collections.load', async () => {
 			const uniqueNames = Array.from(new Set(resourceNames));
 			if (uniqueNames.length === 0)
@@ -368,9 +427,9 @@ export const createCollectionsService = (args: {
 			}
 		});
 
-	const loadEffect: CollectionsService['loadEffect'] = ({ resourceNames, quiet }) =>
+	const load: CollectionsService['load'] = ({ resourceNames, quiet }) =>
 		Effect.tryPromise({
-			try: () => load({ resourceNames, quiet }),
+			try: () => loadPromise({ resourceNames, quiet }),
 			catch: (cause) =>
 				cause instanceof CollectionError
 					? cause
@@ -383,6 +442,6 @@ export const createCollectionsService = (args: {
 
 	return {
 		load,
-		loadEffect
+		loadPromise
 	};
 };