btca-server 1.0.20

package/src/collections/service.ts

@@ -0,0 +1,100 @@
+import { promises as fs } from 'node:fs';
+import path from 'node:path';
+
+import { Config } from '../config/index.ts';
+import { Transaction } from '../context/transaction.ts';
+import { Metrics } from '../metrics/index.ts';
+import { Resources } from '../resources/service.ts';
+import { FS_RESOURCE_SYSTEM_NOTE, type BtcaFsResource } from '../resources/types.ts';
+import { CollectionError, getCollectionKey, type CollectionResult } from './types.ts';
+
+export namespace Collections {
+	export type Service = {
+		load: (args: {
+			resourceNames: readonly string[];
+			quiet?: boolean;
+		}) => Promise<CollectionResult>;
+	};
+
+	const createCollectionInstructionBlock = (resource: BtcaFsResource): string => {
+		const lines = [
+			`## Resource: ${resource.name}`,
+			FS_RESOURCE_SYSTEM_NOTE,
+			`Path: ./${resource.name}`,
+			resource.repoSubPath ? `Focus: ./${resource.name}/${resource.repoSubPath}` : '',
+			resource.specialAgentInstructions ? `Notes: ${resource.specialAgentInstructions}` : ''
+		].filter(Boolean);
+
+		return lines.join('\n');
+	};
+
+	export const create = (args: {
+		config: Config.Service;
+		resources: Resources.Service;
+	}): Service => {
+		return {
+			load: ({ resourceNames, quiet = false }) =>
+				Transaction.run('collections.load', async () => {
+					const uniqueNames = Array.from(new Set(resourceNames));
+					if (uniqueNames.length === 0)
+						throw new CollectionError({ message: 'Cannot create collection with no resources' });
+
+					Metrics.info('collections.load', { resources: uniqueNames, quiet });
+
+					const sortedNames = [...uniqueNames].sort((a, b) => a.localeCompare(b));
+					const key = getCollectionKey(sortedNames);
+					const collectionPath = path.join(args.config.collectionsDirectory, key);
+
+					try {
+						await fs.mkdir(collectionPath, { recursive: true });
+					} catch (cause) {
+						throw new CollectionError({ message: 'Failed to create collection directory', cause });
+					}
+
+					const loadedResources: BtcaFsResource[] = [];
+					for (const name of sortedNames) {
+						try {
+							loadedResources.push(await args.resources.load(name, { quiet }));
+						} catch (cause) {
+							throw new CollectionError({ message: `Failed to load resource ${name}`, cause });
+						}
+					}
+
+					for (const resource of loadedResources) {
+						let resourcePath: string;
+						try {
+							resourcePath = await resource.getAbsoluteDirectoryPath();
+						} catch (cause) {
+							throw new CollectionError({
+								message: `Failed to get path for ${resource.name}`,
+								cause
+							});
+						}
+
+						const linkPath = path.join(collectionPath, resource.name);
+						try {
+							await fs.rm(linkPath, { recursive: true, force: true });
+						} catch {
+							// ignore
+						}
+
+						try {
+							await fs.symlink(resourcePath, linkPath);
+						} catch (cause) {
+							throw new CollectionError({
+								message: `Failed to create symlink for ${resource.name}`,
+								cause
+							});
+						}
+					}
+
+					const instructionBlocks = loadedResources.map(createCollectionInstructionBlock);
+
+					return {
+						path: collectionPath,
+						agentInstructions: instructionBlocks.join('\n\n')
+					};
+				})
+		};
+	};
+}

package/src/collections/types.ts

@@ -0,0 +1,18 @@
+export type CollectionResult = {
+	path: string;
+	agentInstructions: string;
+};
+
+export class CollectionError extends Error {
+	readonly _tag = 'CollectionError';
+	override readonly cause?: unknown;
+
+	constructor(args: { message: string; cause?: unknown }) {
+		super(args.message);
+		this.cause = args.cause;
+	}
+}
+
+export const getCollectionKey = (resourceNames: readonly string[]): string => {
+	return [...resourceNames].sort().join('+');
+};

package/src/config/config.test.ts

@@ -0,0 +1,119 @@
+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 { Config, DEFAULT_MODEL, DEFAULT_PROVIDER, DEFAULT_RESOURCES } from './index.ts';
+
+describe('Config', () => {
+	let testDir: string;
+	let originalCwd: string;
+	let originalHome: string | undefined;
+
+	beforeEach(async () => {
+		testDir = await fs.mkdtemp(path.join(os.tmpdir(), 'btca-config-test-'));
+		originalCwd = process.cwd();
+		originalHome = process.env.HOME;
+		// Point HOME to test dir so global config goes there
+		process.env.HOME = testDir;
+	});
+
+	afterEach(async () => {
+		process.chdir(originalCwd);
+		process.env.HOME = originalHome;
+		await fs.rm(testDir, { recursive: true, force: true });
+	});
+
+	describe('Config.load', () => {
+		it('creates default config when no config exists', async () => {
+			process.chdir(testDir);
+
+			const config = await Config.load();
+
+			expect(config.provider).toBe(DEFAULT_PROVIDER);
+			expect(config.model).toBe(DEFAULT_MODEL);
+			expect(config.resources.length).toBe(DEFAULT_RESOURCES.length);
+			expect(config.getResource('svelte')).toBeDefined();
+		});
+
+		it('loads project config when btca.config.jsonc exists in cwd', async () => {
+			const projectConfig = {
+				$schema: 'https://btca.dev/btca.schema.json',
+				provider: 'test-provider',
+				model: 'test-model',
+				resources: [
+					{
+						name: 'test-resource',
+						type: 'git',
+						url: 'https://github.com/test/repo',
+						branch: 'main'
+					}
+				]
+			};
+
+			await fs.writeFile(path.join(testDir, 'btca.config.jsonc'), JSON.stringify(projectConfig));
+			process.chdir(testDir);
+
+			const config = await Config.load();
+
+			expect(config.provider).toBe('test-provider');
+			expect(config.model).toBe('test-model');
+			expect(config.resources.length).toBe(1);
+			expect(config.resources[0]?.name).toBe('test-resource');
+		});
+
+		it('handles JSONC with comments', async () => {
+			const projectConfigWithComments = `{
+				// This is a comment
+				"$schema": "https://btca.dev/btca.schema.json",
+				"provider": "commented-provider",
+				"model": "commented-model",
+				/* Multi-line
+				   comment */
+				"resources": [
+					{
+						"name": "commented-resource",
+						"type": "git",
+						"url": "https://github.com/test/repo",
+						"branch": "main",
+					}
+				],
+			}`;
+
+			await fs.writeFile(path.join(testDir, 'btca.config.jsonc'), projectConfigWithComments);
+			process.chdir(testDir);
+
+			const config = await Config.load();
+
+			expect(config.provider).toBe('commented-provider');
+			expect(config.model).toBe('commented-model');
+		});
+
+		it('getResource returns undefined for unknown resource', async () => {
+			process.chdir(testDir);
+
+			const config = await Config.load();
+
+			expect(config.getResource('nonexistent')).toBeUndefined();
+		});
+
+		it('throws ConfigError for invalid JSON', async () => {
+			await fs.writeFile(path.join(testDir, 'btca.config.jsonc'), 'not valid json {{{');
+			process.chdir(testDir);
+
+			expect(Config.load()).rejects.toThrow('Failed to parse config JSONC');
+		});
+
+		it('throws ConfigError for invalid schema', async () => {
+			const invalidConfig = {
+				provider: 'test'
+				// missing required fields
+			};
+
+			await fs.writeFile(path.join(testDir, 'btca.config.jsonc'), JSON.stringify(invalidConfig));
+			process.chdir(testDir);
+
+			expect(Config.load()).rejects.toThrow('Invalid config');
+		});
+	});
+});