btca-server 2.0.2 → 2.0.4

package/src/collections/service.test.ts

@@ -0,0 +1,256 @@
+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 { ResourceDefinition } from '../resources/schema.ts';
+import type { ResourcesService } from '../resources/service.ts';
+import type { BtcaFsResource } from '../resources/types.ts';
+import { createCollectionsService } from './service.ts';
+import { disposeVirtualFs, existsInVirtualFs } from '../vfs/virtual-fs.ts';
+
+const createFsResource = ({
+	name,
+	resourcePath,
+	type = 'local',
+	repoSubPaths = [],
+	specialAgentInstructions = ''
+}: {
+	name: string;
+	resourcePath: string;
+	type?: BtcaFsResource['type'];
+	repoSubPaths?: readonly string[];
+	specialAgentInstructions?: string;
+}) => ({
+	_tag: 'fs-based' as const,
+	name,
+	fsName: name,
+	type,
+	repoSubPaths,
+	specialAgentInstructions,
+	getAbsoluteDirectoryPath: async () => resourcePath
+});
+
+const createConfigMock = (definitions: Record<string, ResourceDefinition> = {}) =>
+	({
+		getResource: (name: string) => definitions[name]
+	}) as unknown as ConfigService;
+
+const createResourcesMock = (loadPromise: ResourcesService['loadPromise']) =>
+	({
+		load: () => {
+			throw new Error('Not implemented in test');
+		},
+		loadPromise
+	}) 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(async () => createFsResource({ name: 'repo', 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(async () => createFsResource({ name: 'repo', 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);
+				expect(collection.agentInstructions).not.toContain('<special_notes>');
+			} finally {
+				await cleanupCollection(collection);
+			}
+		} finally {
+			await fs.rm(resourcePath, { recursive: true, force: true });
+		}
+	});
+
+	it('includes git citation metadata in agent instructions', async () => {
+		const resourcePath = await fs.mkdtemp(path.join(os.tmpdir(), 'btca-collections-git-meta-'));
+		const collections = createCollectionsService({
+			config: createConfigMock({
+				docs: {
+					type: 'git',
+					name: 'docs',
+					url: 'https://github.com/example/repo.git',
+					branch: 'main',
+					searchPath: 'guides',
+					specialNotes: 'Prefer the guides folder.'
+				}
+			}),
+			resources: createResourcesMock(async () =>
+				createFsResource({
+					name: 'docs',
+					resourcePath,
+					type: 'git',
+					repoSubPaths: ['guides'],
+					specialAgentInstructions: 'Prefer the guides folder.'
+				})
+			)
+		});
+
+		try {
+			await fs.writeFile(path.join(resourcePath, 'README.md'), 'hello\n');
+			runGit(resourcePath, ['init', '-q']);
+			runGit(resourcePath, ['config', 'user.email', 'test@example.com']);
+			runGit(resourcePath, ['config', 'user.name', 'BTCA Test']);
+			runGit(resourcePath, ['add', 'README.md']);
+			runGit(resourcePath, ['commit', '-m', 'init']);
+
+			const collection = await collections.loadPromise({ resourceNames: ['docs'] });
+
+			try {
+				expect(collection.agentInstructions).toContain(
+					'<repo_url>https://github.com/example/repo</repo_url>'
+				);
+				expect(collection.agentInstructions).toContain('<repo_branch>main</repo_branch>');
+				expect(collection.agentInstructions).toContain(
+					'<github_blob_prefix>https://github.com/example/repo/blob/main</github_blob_prefix>'
+				);
+				expect(collection.agentInstructions).toContain(
+					'<citation_rule>Convert virtual paths under ./docs/ to repo-relative paths, then encode each path segment for GitHub URLs.</citation_rule>'
+				);
+				expect(collection.agentInstructions).toContain('<path>./docs/guides</path>');
+				expect(collection.agentInstructions).toContain('<repo_commit>');
+				expect(collection.agentInstructions).toContain(
+					'<special_notes>Prefer the guides folder.</special_notes>'
+				);
+			} finally {
+				await cleanupCollection(collection);
+			}
+		} finally {
+			await fs.rm(resourcePath, { recursive: true, force: true });
+		}
+	});
+
+	it('includes npm citation metadata in agent instructions', async () => {
+		const resourcePath = await fs.mkdtemp(path.join(os.tmpdir(), 'btca-collections-npm-meta-'));
+		const collections = createCollectionsService({
+			config: createConfigMock({
+				react: {
+					type: 'npm',
+					name: 'react',
+					package: 'react',
+					version: '19.0.0',
+					specialNotes: 'Use package docs.'
+				}
+			}),
+			resources: createResourcesMock(async () =>
+				createFsResource({
+					name: 'react',
+					resourcePath,
+					type: 'npm',
+					specialAgentInstructions: 'Use package docs.'
+				})
+			)
+		});
+
+		try {
+			await fs.writeFile(
+				path.join(resourcePath, '.btca-npm-meta.json'),
+				JSON.stringify({
+					packageName: 'react',
+					resolvedVersion: '19.0.0',
+					packageUrl: 'https://www.npmjs.com/package/react'
+				})
+			);
+			await fs.writeFile(path.join(resourcePath, 'README.md'), 'react docs\n');
+
+			const collection = await collections.loadPromise({ resourceNames: ['react'] });
+
+			try {
+				expect(collection.agentInstructions).toContain('<npm_package>react</npm_package>');
+				expect(collection.agentInstructions).toContain('<npm_version>19.0.0</npm_version>');
+				expect(collection.agentInstructions).toContain(
+					'<npm_url>https://www.npmjs.com/package/react</npm_url>'
+				);
+				expect(collection.agentInstructions).toContain(
+					'<npm_citation_alias>npm:react@19.0.0</npm_citation_alias>'
+				);
+				expect(collection.agentInstructions).toContain(
+					'<npm_file_url_prefix>https://unpkg.com/react@19.0.0</npm_file_url_prefix>'
+				);
+				expect(collection.agentInstructions).toContain(
+					'<citation_rule>In Sources, cite npm files using npm:react@19.0.0/&lt;file&gt; and link them to https://unpkg.com/react@19.0.0/&lt;file&gt;. Do not cite encoded virtual folder names.</citation_rule>'
+				);
+				expect(collection.agentInstructions).toContain(
+					'<citation_example>https://unpkg.com/react@19.0.0/package.json</citation_example>'
+				);
+				expect(collection.agentInstructions).toContain(
+					'<special_notes>Use package docs.</special_notes>'
+				);
+			} 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,63 +26,120 @@ 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('/');
+const escapeXml = (value: string) =>
+	value
+		.replaceAll('&', '&amp;')
+		.replaceAll('<', '&lt;')
+		.replaceAll('>', '&gt;')
+		.replaceAll('"', '&quot;')
+		.replaceAll("'", '&apos;');
+
+const getResourceTypeLabel = (resource: BtcaFsResource) => {
+	if (resource.type === 'git') return 'git repo';
+	if (resource.type === 'npm') return 'npm package';
+	return 'local directory';
+};
 
 const trimGitSuffix = (url: string) => url.replace(/\.git$/u, '').replace(/\/+$/u, '');
+
+const encodePathSegments = (value: string) => value.split('/').map(encodeURIComponent).join('/');
+
+const xmlLine = (tag: string, value?: string) =>
+	value ? `\t\t<${tag}>${escapeXml(value)}</${tag}>` : '';
+
+const xmlPathBlock = (tag: string, values: readonly string[], prefix = '') =>
+	values.length === 0
+		? ''
+		: [
+				`\t\t<${tag}>`,
+				...values.map((value) => `\t\t\t<path>${escapeXml(`${prefix}${value}`)}</path>`),
+				`\t\t</${tag}>`
+			].join('\n');
+
 const getNpmCitationAlias = (metadata?: VirtualResourceMetadata) => {
 	if (!metadata?.package) return undefined;
 	return `npm:${metadata.package}@${metadata.version ?? 'latest'}`;
 };
 
+const getNpmFileUrlPrefix = (metadata?: VirtualResourceMetadata) => {
+	if (!metadata?.package || !metadata?.version) return undefined;
+	return `https://unpkg.com/${metadata.package}@${metadata.version}`;
+};
+
 const createCollectionInstructionBlock = (
 	resource: BtcaFsResource,
 	metadata?: VirtualResourceMetadata
-): string => {
-	const focusLines = resource.repoSubPaths.map(
-		(subPath) => `Focus: ./${resource.fsName}/${subPath}`
-	);
+) => {
+	const repoUrl =
+		resource.type === 'git' && metadata?.url ? trimGitSuffix(metadata.url) : undefined;
 	const gitRef = metadata?.branch ?? metadata?.commit;
-	const githubPrefix =
-		resource.type === 'git' && metadata?.url && gitRef
-			? `${trimGitSuffix(metadata.url)}/blob/${encodeURIComponent(gitRef)}`
-			: undefined;
+	const githubBlobPrefix =
+		repoUrl && gitRef ? `${repoUrl}/blob/${encodeURIComponent(gitRef)}` : undefined;
 	const npmCitationAlias = resource.type === 'npm' ? getNpmCitationAlias(metadata) : undefined;
-	const lines = [
-		`## Resource: ${resource.name}`,
-		FS_RESOURCE_SYSTEM_NOTE,
-		`Path: ./${resource.fsName}`,
-		resource.type === 'git' && metadata?.url ? `Repo URL: ${trimGitSuffix(metadata.url)}` : '',
-		resource.type === 'git' && metadata?.branch ? `Repo Branch: ${metadata.branch}` : '',
-		resource.type === 'git' && metadata?.commit ? `Repo Commit: ${metadata.commit}` : '',
-		resource.type === 'npm' && metadata?.package ? `NPM Package: ${metadata.package}` : '',
-		resource.type === 'npm' && metadata?.version ? `NPM Version: ${metadata.version}` : '',
-		resource.type === 'npm' && metadata?.url ? `NPM URL: ${metadata.url}` : '',
-		npmCitationAlias ? `NPM Citation Alias: ${npmCitationAlias}` : '',
-		githubPrefix ? `GitHub Blob Prefix: ${githubPrefix}` : '',
-		githubPrefix
-			? `GitHub Citation Rule: Convert virtual paths under ./${resource.fsName}/ to repo-relative paths, then encode each path segment for GitHub URLs (example segment: "+page.server.js" -> "${encodeURIComponent('+page.server.js')}").`
-			: '',
-		githubPrefix
-			? `GitHub Citation Example: ${githubPrefix}/${encodePathSegments('src/routes/blog/+page.server.js')}`
-			: '',
-		resource.type !== 'git'
-			? 'Citation Rule: Cite local file paths only for this resource (no GitHub URL).'
-			: '',
-		npmCitationAlias
-			? `NPM Citation Rule: In "Sources", cite npm files using "${npmCitationAlias}/<file>" (for example, "${npmCitationAlias}/README.md"). Do not cite encoded virtual folder names.`
-			: '',
-		...focusLines,
-		resource.specialAgentInstructions ? `Notes: ${resource.specialAgentInstructions}` : ''
-	].filter(Boolean);
-
-	return lines.join('\n');
+	const npmFileUrlPrefix = resource.type === 'npm' ? getNpmFileUrlPrefix(metadata) : undefined;
+
+	return [
+		'\t<resource>',
+		`\t\t<name>${escapeXml(resource.name)}</name>`,
+		`\t\t<type>${getResourceTypeLabel(resource)}</type>`,
+		`\t\t<system_note>${escapeXml(FS_RESOURCE_SYSTEM_NOTE)}</system_note>`,
+		`\t\t<path>${escapeXml(`./${resource.fsName}`)}</path>`,
+		xmlLine('repo_url', repoUrl),
+		xmlLine('repo_branch', resource.type === 'git' ? metadata?.branch : undefined),
+		xmlLine('repo_commit', resource.type === 'git' ? metadata?.commit : undefined),
+		xmlLine('npm_package', resource.type === 'npm' ? metadata?.package : undefined),
+		xmlLine('npm_version', resource.type === 'npm' ? metadata?.version : undefined),
+		xmlLine('npm_url', resource.type === 'npm' ? metadata?.url : undefined),
+		xmlLine('npm_citation_alias', npmCitationAlias),
+		xmlLine('npm_file_url_prefix', npmFileUrlPrefix),
+		xmlLine('github_blob_prefix', githubBlobPrefix),
+		xmlLine(
+			'citation_rule',
+			githubBlobPrefix
+				? `Convert virtual paths under ./${resource.fsName}/ to repo-relative paths, then encode each path segment for GitHub URLs.`
+				: resource.type === 'npm' && npmCitationAlias
+					? `In Sources, cite npm files using ${npmCitationAlias}/<file> and link them to ${npmFileUrlPrefix ?? 'the exact file URL prefix'}/<file>. Do not cite encoded virtual folder names.`
+					: 'Cite local file paths only for this resource.'
+		),
+		xmlLine(
+			'citation_example',
+			githubBlobPrefix
+				? `${githubBlobPrefix}/${encodePathSegments('src/routes/blog/+page.server.js')}`
+				: resource.type === 'npm' && npmCitationAlias && npmFileUrlPrefix
+					? `${npmFileUrlPrefix}/package.json`
+					: undefined
+		),
+		xmlPathBlock('focus_paths', resource.repoSubPaths, `./${resource.fsName}/`),
+		xmlLine('special_notes', resource.specialAgentInstructions),
+		'\t</resource>'
+	]
+		.filter(Boolean)
+		.join('\n');
+};
+
+const createCollectionInstructions = (
+	resources: readonly BtcaFsResource[],
+	metadataResources: readonly VirtualResourceMetadata[]
+) => {
+	const metadataByName = new Map(metadataResources.map((resource) => [resource.name, resource]));
+
+	return [
+		'<available_resources>',
+		...resources.map((resource) =>
+			createCollectionInstructionBlock(resource, metadataByName.get(resource.name))
+		),
+		'</available_resources>'
+	].join('\n');
 };
 
 const ignoreErrors = async (action: () => Promise<unknown>) => {
@@ -92,6 +150,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 +211,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 +244,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 +383,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)
@@ -341,16 +454,9 @@ export const createCollectionsService = (args: {
 					resources: metadataResources
 				});
 
-				const metadataByName = new Map(
-					metadataResources.map((resource) => [resource.name, resource])
-				);
-				const instructionBlocks = loadedResources.map((resource) =>
-					createCollectionInstructionBlock(resource, metadataByName.get(resource.name))
-				);
-
 				return {
 					path: collectionPath,
-					agentInstructions: instructionBlocks.join('\n\n'),
+					agentInstructions: createCollectionInstructions(loadedResources, metadataResources),
 					vfsId,
 					cleanup: async () => {
 						await cleanupResources(loadedResources);
@@ -368,9 +474,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 +489,6 @@ export const createCollectionsService = (args: {
 
 	return {
 		load,
-		loadEffect
+		loadPromise
 	};
 };

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